dify-oapi2 0.4.0__py3-none-any.whl → 0.5.0__py3-none-any.whl

dify_oapi/api/chatflow/v1/resource/file.py

@@ -0,0 +1,39 @@
+from __future__ import annotations
+
+from dify_oapi.core.http.transport import ATransport, Transport
+from dify_oapi.core.model.config import Config
+from dify_oapi.core.model.request_option import RequestOption
+
+from ..model.upload_file_request import UploadFileRequest
+from ..model.upload_file_response import UploadFileResponse
+
+
+class File:
+    """File resource for chatflow API operations."""
+
+    def __init__(self, config: Config):
+        self.config = config
+
+    def upload(self, request: UploadFileRequest, request_option: RequestOption) -> UploadFileResponse:
+        """Upload file for multimodal support.
+
+        Args:
+            request: Upload file request
+            request_option: Request options including API key
+
+        Returns:
+            Upload file response with file information
+        """
+        return Transport.execute(self.config, request, unmarshal_as=UploadFileResponse, option=request_option)
+
+    async def aupload(self, request: UploadFileRequest, request_option: RequestOption) -> UploadFileResponse:
+        """Upload file for multimodal support (async).
+
+        Args:
+            request: Upload file request
+            request_option: Request options including API key
+
+        Returns:
+            Upload file response with file information
+        """
+        return await ATransport.aexecute(self.config, request, unmarshal_as=UploadFileResponse, option=request_option)

dify_oapi/api/chatflow/v1/resource/tts.py

@@ -0,0 +1,29 @@
+from dify_oapi.api.chatflow.v1.model.audio_to_text_request import AudioToTextRequest
+from dify_oapi.api.chatflow.v1.model.audio_to_text_response import AudioToTextResponse
+from dify_oapi.api.chatflow.v1.model.text_to_audio_request import TextToAudioRequest
+from dify_oapi.api.chatflow.v1.model.text_to_audio_response import TextToAudioResponse
+from dify_oapi.core.http.transport.async_transport import ATransport
+from dify_oapi.core.http.transport.sync_transport import Transport
+from dify_oapi.core.model.config import Config
+from dify_oapi.core.model.request_option import RequestOption
+
+
+class TTS:
+    def __init__(self, config: Config):
+        self.config = config
+
+    def speech_to_text(self, request: AudioToTextRequest, request_option: RequestOption) -> AudioToTextResponse:
+        """Convert audio to text (sync)"""
+        return Transport.execute(self.config, request, unmarshal_as=AudioToTextResponse, option=request_option)
+
+    async def aspeech_to_text(self, request: AudioToTextRequest, request_option: RequestOption) -> AudioToTextResponse:
+        """Convert audio to text (async)"""
+        return await ATransport.aexecute(self.config, request, unmarshal_as=AudioToTextResponse, option=request_option)
+
+    def text_to_audio(self, request: TextToAudioRequest, request_option: RequestOption) -> TextToAudioResponse:
+        """Convert text to audio (sync)"""
+        return Transport.execute(self.config, request, unmarshal_as=TextToAudioResponse, option=request_option)
+
+    async def atext_to_audio(self, request: TextToAudioRequest, request_option: RequestOption) -> TextToAudioResponse:
+        """Convert text to audio (async)"""
+        return await ATransport.aexecute(self.config, request, unmarshal_as=TextToAudioResponse, option=request_option)

dify_oapi/api/chatflow/v1/version.py

@@ -0,0 +1,29 @@
+"""Chatflow API V1 version integration."""
+
+from dify_oapi.core.model.config import Config
+
+from .resource.annotation import Annotation
+from .resource.application import Application
+from .resource.chatflow import Chatflow
+from .resource.conversation import Conversation
+from .resource.feedback import Feedback
+from .resource.file import File
+from .resource.tts import TTS
+
+
+class V1:
+    """Chatflow API V1 version class that integrates all resources."""
+
+    def __init__(self, config: Config):
+        """Initialize V1 with all chatflow resources.
+
+        Args:
+            config: Configuration object containing API settings
+        """
+        self.chatflow = Chatflow(config)
+        self.file = File(config)
+        self.feedback = Feedback(config)
+        self.conversation = Conversation(config)
+        self.tts = TTS(config)
+        self.application = Application(config)
+        self.annotation = Annotation(config)

dify_oapi/api/knowledge/v1/model/data_source_detail.py

@@ -0,0 +1,23 @@
+"""Data source detail models."""
+
+from typing import Optional
+
+from pydantic import BaseModel
+
+
+class UploadFileDetail(BaseModel):
+    """Upload file detail information."""
+
+    id: Optional[str] = None
+    name: Optional[str] = None
+    size: Optional[int] = None
+    extension: Optional[str] = None
+    mime_type: Optional[str] = None
+    created_by: Optional[str] = None
+    created_at: Optional[float] = None
+
+
+class DataSourceDetailDict(BaseModel):
+    """Data source detail dictionary."""
+
+    upload_file: Optional[UploadFileDetail] = None

dify_oapi/api/knowledge/v1/model/dataset_info.py

@@ -4,9 +4,10 @@ from typing import Optional
 
 from pydantic import BaseModel
 
-from .document_metadata import DocumentMetadata
+from .dataset_metadata import DatasetMetadata
 from .external_knowledge_info import ExternalKnowledgeInfo
-from .knowledge_types import DataSourceType, IndexingTechnique, Permission
+from .external_retrieval_model import ExternalRetrievalModel
+from .knowledge_types import DataSourceType, DocumentForm, IndexingTechnique, Permission
 from .retrieval_model import RetrievalModel
 from .tag_info import TagInfo
 
@@ -25,18 +26,18 @@ class DatasetInfo(BaseModel):
     document_count: Optional[int] = None
     word_count: Optional[int] = None
     created_by: Optional[str] = None
-    created_at: Optional[float] = None
+    created_at: Optional[int] = None
     updated_by: Optional[str] = None
-    updated_at: Optional[float] = None
+    updated_at: Optional[int] = None
     embedding_model: Optional[str] = None
     embedding_model_provider: Optional[str] = None
     embedding_available: Optional[bool] = None
     retrieval_model_dict: Optional[RetrievalModel] = None
     tags: Optional[list[TagInfo]] = None
-    doc_form: Optional[str] = None
+    doc_form: Optional[DocumentForm] = None
     external_knowledge_info: Optional[ExternalKnowledgeInfo] = None
-    external_retrieval_model: Optional[RetrievalModel] = None
-    doc_metadata: Optional[list[DocumentMetadata]] = None
+    external_retrieval_model: Optional[ExternalRetrievalModel] = None
+    doc_metadata: Optional[list[DatasetMetadata]] = None
     built_in_field_enabled: Optional[bool] = None
 
     @staticmethod
@@ -89,7 +90,7 @@ class DatasetInfoBuilder:
         self._dataset_info.created_by = created_by
         return self
 
-    def created_at(self, created_at: float) -> "DatasetInfoBuilder":
+    def created_at(self, created_at: int) -> "DatasetInfoBuilder":
         self._dataset_info.created_at = created_at
         return self
 
@@ -97,7 +98,7 @@ class DatasetInfoBuilder:
         self._dataset_info.updated_by = updated_by
         return self
 
-    def updated_at(self, updated_at: float) -> "DatasetInfoBuilder":
+    def updated_at(self, updated_at: int) -> "DatasetInfoBuilder":
         self._dataset_info.updated_at = updated_at
         return self
 

dify_oapi/api/knowledge/v1/model/dataset_metadata.py

@@ -0,0 +1,14 @@
+"""Dataset metadata model."""
+
+from typing import Optional
+
+from pydantic import BaseModel
+
+
+class DatasetMetadata(BaseModel):
+    """Dataset metadata information."""
+
+    # Based on API response, this is typically an empty array
+    # Can be extended when actual metadata structure is known
+    key: Optional[str] = None
+    value: Optional[str] = None

dify_oapi/api/knowledge/v1/model/document_info.py

@@ -4,7 +4,9 @@ from typing import Optional
 
 from pydantic import BaseModel
 
+from .data_source_detail import DataSourceDetailDict
 from .data_source_info import DataSourceInfo
+from .document_metadata import DocumentMetadata
 from .knowledge_types import DataSourceType, DocumentDisplayStatus, DocumentForm, IndexingStatus
 
 
@@ -15,23 +17,25 @@ class DocumentInfo(BaseModel):
     position: Optional[int] = None
     data_source_type: Optional[DataSourceType] = None
     data_source_info: Optional["DataSourceInfo"] = None
+    data_source_detail_dict: Optional[DataSourceDetailDict] = None
     dataset_process_rule_id: Optional[str] = None
     name: Optional[str] = None
     created_from: Optional[str] = None
     created_by: Optional[str] = None
-    created_at: Optional[float] = None
+    created_at: Optional[int] = None
     tokens: Optional[int] = None
     indexing_status: Optional[IndexingStatus] = None
     error: Optional[str] = None
     enabled: Optional[bool] = None
-    disabled_at: Optional[float] = None
+    disabled_at: Optional[int] = None
     disabled_by: Optional[str] = None
     archived: Optional[bool] = None
     display_status: Optional[DocumentDisplayStatus] = None
     word_count: Optional[int] = None
     hit_count: Optional[int] = None
     doc_form: Optional[DocumentForm] = None
-    updated_at: Optional[float] = None
+    doc_metadata: Optional[DocumentMetadata] = None
+    updated_at: Optional[int] = None
 
     @staticmethod
     def builder() -> "DocumentInfoBuilder":
@@ -63,6 +67,10 @@ class DocumentInfoBuilder:
         self._document_info.data_source_info = data_source_info
         return self
 
+    def data_source_detail_dict(self, data_source_detail_dict: DataSourceDetailDict) -> "DocumentInfoBuilder":
+        self._document_info.data_source_detail_dict = data_source_detail_dict
+        return self
+
     def dataset_process_rule_id(self, dataset_process_rule_id: str) -> "DocumentInfoBuilder":
         self._document_info.dataset_process_rule_id = dataset_process_rule_id
         return self
@@ -79,7 +87,7 @@ class DocumentInfoBuilder:
         self._document_info.created_by = created_by
         return self
 
-    def created_at(self, created_at: float) -> "DocumentInfoBuilder":
+    def created_at(self, created_at: int) -> "DocumentInfoBuilder":
         self._document_info.created_at = created_at
         return self
 
@@ -99,7 +107,7 @@ class DocumentInfoBuilder:
         self._document_info.enabled = enabled
         return self
 
-    def disabled_at(self, disabled_at: float) -> "DocumentInfoBuilder":
+    def disabled_at(self, disabled_at: int) -> "DocumentInfoBuilder":
         self._document_info.disabled_at = disabled_at
         return self
 
@@ -127,6 +135,10 @@ class DocumentInfoBuilder:
         self._document_info.doc_form = doc_form
         return self
 
-    def updated_at(self, updated_at: float) -> "DocumentInfoBuilder":
+    def doc_metadata(self, doc_metadata: DocumentMetadata) -> "DocumentInfoBuilder":
+        self._document_info.doc_metadata = doc_metadata
+        return self
+
+    def updated_at(self, updated_at: int) -> "DocumentInfoBuilder":
         self._document_info.updated_at = updated_at
         return self

dify_oapi/api/knowledge/v1/model/external_knowledge_info.py

@@ -8,8 +8,10 @@ from pydantic import BaseModel
 class ExternalKnowledgeInfo(BaseModel):
     """External knowledge info model with builder pattern."""
 
-    external_knowledge_api_id: Optional[str] = None
     external_knowledge_id: Optional[str] = None
+    external_knowledge_api_id: Optional[str] = None
+    external_knowledge_api_name: Optional[str] = None
+    external_knowledge_api_endpoint: Optional[str] = None
 
     @staticmethod
     def builder() -> "ExternalKnowledgeInfoBuilder":
@@ -32,3 +34,11 @@ class ExternalKnowledgeInfoBuilder:
     def external_knowledge_id(self, external_knowledge_id: str) -> "ExternalKnowledgeInfoBuilder":
         self._external_knowledge_info.external_knowledge_id = external_knowledge_id
         return self
+
+    def external_knowledge_api_name(self, external_knowledge_api_name: str) -> "ExternalKnowledgeInfoBuilder":
+        self._external_knowledge_info.external_knowledge_api_name = external_knowledge_api_name
+        return self
+
+    def external_knowledge_api_endpoint(self, external_knowledge_api_endpoint: str) -> "ExternalKnowledgeInfoBuilder":
+        self._external_knowledge_info.external_knowledge_api_endpoint = external_knowledge_api_endpoint
+        return self

dify_oapi/api/knowledge/v1/model/external_retrieval_model.py

@@ -0,0 +1,13 @@
+"""External retrieval model for Knowledge Base API."""
+
+from typing import Optional
+
+from pydantic import BaseModel
+
+
+class ExternalRetrievalModel(BaseModel):
+    """External retrieval model configuration."""
+
+    top_k: Optional[int] = None
+    score_threshold: Optional[float] = None
+    score_threshold_enabled: Optional[bool] = None

dify_oapi/api/knowledge/v1/model/knowledge_types.py

@@ -15,7 +15,7 @@ SearchMethod = Literal["hybrid_search", "semantic_search", "full_text_search", "
 DocumentStatus = Literal["indexing", "completed", "error", "paused"]
 
 # Processing mode types
-ProcessingMode = Literal["automatic", "custom"]
+ProcessingMode = Literal["automatic", "custom", "hierarchical"]
 
 # File types
 FileType = Literal["document", "image", "audio", "video", "custom"]
@@ -79,7 +79,7 @@ ExternalKnowledgeProvider = Literal["external_api", "notion", "web_crawler"]
 DocumentCreatedFrom = Literal["api", "web", "upload"]
 
 # Document display status types
-DocumentDisplayStatus = Literal["available", "indexing", "error", "paused", "archived"]
+DocumentDisplayStatus = Literal["available", "indexing", "error", "paused", "archived", "queuing"]
 
 # Batch processing status types
 BatchProcessingStatus = Literal["processing", "completed", "failed", "cancelled"]

dify_oapi/api/knowledge/v1/model/retrieval_model.py

@@ -6,6 +6,7 @@ from pydantic import BaseModel
 
 from .knowledge_types import SearchMethod
 from .reranking_mode import RerankingMode
+from .weights import Weights
 
 
 class RetrievalModel(BaseModel):
@@ -13,11 +14,12 @@ class RetrievalModel(BaseModel):
 
     search_method: Optional[SearchMethod] = None
     reranking_enable: Optional[bool] = None
-    reranking_mode: Optional[RerankingMode] = None
+    reranking_mode: Optional[str] = None
+    reranking_model: Optional[RerankingMode] = None
     top_k: Optional[int] = None
     score_threshold_enabled: Optional[bool] = None
     score_threshold: Optional[float] = None
-    weights: Optional[float] = None
+    weights: Optional[Weights] = None
 
     @staticmethod
     def builder() -> "RetrievalModelBuilder":
@@ -41,10 +43,14 @@ class RetrievalModelBuilder:
         self._retrieval_model.reranking_enable = reranking_enable
         return self
 
-    def reranking_mode(self, reranking_mode: RerankingMode) -> "RetrievalModelBuilder":
+    def reranking_mode(self, reranking_mode: str) -> "RetrievalModelBuilder":
         self._retrieval_model.reranking_mode = reranking_mode
         return self
 
+    def reranking_model(self, reranking_model: RerankingMode) -> "RetrievalModelBuilder":
+        self._retrieval_model.reranking_model = reranking_model
+        return self
+
     def top_k(self, top_k: int) -> "RetrievalModelBuilder":
         self._retrieval_model.top_k = top_k
         return self
@@ -57,6 +63,6 @@ class RetrievalModelBuilder:
         self._retrieval_model.score_threshold = score_threshold
         return self
 
-    def weights(self, weights: float) -> "RetrievalModelBuilder":
+    def weights(self, weights: Weights) -> "RetrievalModelBuilder":
         self._retrieval_model.weights = weights
         return self

dify_oapi/api/knowledge/v1/model/weights.py

@@ -0,0 +1,27 @@
+"""Weights model for retrieval configuration."""
+
+from typing import Optional
+
+from pydantic import BaseModel
+
+
+class KeywordSetting(BaseModel):
+    """Keyword search weight settings."""
+
+    keyword_weight: Optional[float] = None
+
+
+class VectorSetting(BaseModel):
+    """Vector search weight settings."""
+
+    vector_weight: Optional[float] = None
+    embedding_model_name: Optional[str] = None
+    embedding_provider_name: Optional[str] = None
+
+
+class Weights(BaseModel):
+    """Weights configuration for hybrid search."""
+
+    weight_type: Optional[str] = None
+    keyword_setting: Optional[KeywordSetting] = None
+    vector_setting: Optional[VectorSetting] = None

dify_oapi/api/workflow/v1/model/chunk_workflow_event.py

@@ -0,0 +1,74 @@
+"""Chunk workflow event for streaming mode.
+
+This module defines the base structure for workflow streaming events
+and specific event data models.
+"""
+
+from typing import Any, Optional
+
+from pydantic import BaseModel
+
+from .workflow_types import EventType
+
+
+class ChunkWorkflowEvent(BaseModel):
+    """Base streaming event structure for workflow execution."""
+
+    event: EventType
+    task_id: Optional[str] = None
+    workflow_run_id: Optional[str] = None
+    data: Optional[dict[str, Any]] = None
+    message_id: Optional[str] = None
+    audio: Optional[str] = None
+    created_at: Optional[int] = None
+
+    @staticmethod
+    def builder() -> "ChunkWorkflowEventBuilder":
+        """Create a new ChunkWorkflowEvent builder."""
+        return ChunkWorkflowEventBuilder()
+
+
+class ChunkWorkflowEventBuilder:
+    """Builder for ChunkWorkflowEvent."""
+
+    def __init__(self):
+        self._chunk_workflow_event = ChunkWorkflowEvent(event="ping")
+
+    def build(self) -> ChunkWorkflowEvent:
+        """Build the ChunkWorkflowEvent instance."""
+        return self._chunk_workflow_event
+
+    def event(self, event: EventType) -> "ChunkWorkflowEventBuilder":
+        """Set the event type."""
+        self._chunk_workflow_event.event = event
+        return self
+
+    def task_id(self, task_id: str) -> "ChunkWorkflowEventBuilder":
+        """Set the task ID."""
+        self._chunk_workflow_event.task_id = task_id
+        return self
+
+    def workflow_run_id(self, workflow_run_id: str) -> "ChunkWorkflowEventBuilder":
+        """Set the workflow run ID."""
+        self._chunk_workflow_event.workflow_run_id = workflow_run_id
+        return self
+
+    def data(self, data: dict[str, Any]) -> "ChunkWorkflowEventBuilder":
+        """Set the event data."""
+        self._chunk_workflow_event.data = data
+        return self
+
+    def message_id(self, message_id: str) -> "ChunkWorkflowEventBuilder":
+        """Set the message ID (for TTS events)."""
+        self._chunk_workflow_event.message_id = message_id
+        return self
+
+    def audio(self, audio: str) -> "ChunkWorkflowEventBuilder":
+        """Set the audio data (for TTS events)."""
+        self._chunk_workflow_event.audio = audio
+        return self
+
+    def created_at(self, created_at: int) -> "ChunkWorkflowEventBuilder":
+        """Set the creation timestamp."""
+        self._chunk_workflow_event.created_at = created_at
+        return self

dify_oapi/api/workflow/v1/model/input_file_object_workflow.py

@@ -0,0 +1,76 @@
+"""Input file object for workflow multimodal support.
+
+This module defines the InputFileObjectWorkflow model for handling file inputs
+in workflow execution with proper validation rules.
+"""
+
+from typing import Optional
+
+from pydantic import BaseModel, model_validator
+
+from .workflow_types import FileType, TransferMethod
+
+
+class InputFileObjectWorkflow(BaseModel):
+    """File input object for workflow execution.
+
+    Supports both remote URL and local file upload methods with validation rules:
+    - When transfer_method is "remote_url": url is required, upload_file_id must be None
+    - When transfer_method is "local_file": upload_file_id is required, url must be None
+    """
+
+    type: FileType
+    transfer_method: TransferMethod
+    url: Optional[str] = None
+    upload_file_id: Optional[str] = None
+
+    @model_validator(mode="after")
+    def validate_transfer_method_fields(self):
+        """Validate that the correct fields are provided based on transfer_method."""
+        if self.transfer_method == "remote_url":
+            if not self.url:
+                raise ValueError("url is required when transfer_method is 'remote_url'")
+            if self.upload_file_id is not None:
+                raise ValueError("upload_file_id must be None when transfer_method is 'remote_url'")
+        elif self.transfer_method == "local_file":
+            if not self.upload_file_id:
+                raise ValueError("upload_file_id is required when transfer_method is 'local_file'")
+            if self.url is not None:
+                raise ValueError("url must be None when transfer_method is 'local_file'")
+        return self
+
+    @staticmethod
+    def builder() -> "InputFileObjectWorkflowBuilder":
+        """Create a new InputFileObjectWorkflow builder."""
+        return InputFileObjectWorkflowBuilder()
+
+
+class InputFileObjectWorkflowBuilder:
+    """Builder for InputFileObjectWorkflow."""
+
+    def __init__(self):
+        self._input_file_object_workflow = InputFileObjectWorkflow(type="document", transfer_method="local_file")
+
+    def build(self) -> InputFileObjectWorkflow:
+        """Build the InputFileObjectWorkflow instance."""
+        return self._input_file_object_workflow
+
+    def type(self, file_type: FileType) -> "InputFileObjectWorkflowBuilder":
+        """Set the file type."""
+        self._input_file_object_workflow.type = file_type
+        return self
+
+    def transfer_method(self, transfer_method: TransferMethod) -> "InputFileObjectWorkflowBuilder":
+        """Set the transfer method."""
+        self._input_file_object_workflow.transfer_method = transfer_method
+        return self
+
+    def url(self, url: str) -> "InputFileObjectWorkflowBuilder":
+        """Set the remote URL (for remote_url transfer method)."""
+        self._input_file_object_workflow.url = url
+        return self
+
+    def upload_file_id(self, upload_file_id: str) -> "InputFileObjectWorkflowBuilder":
+        """Set the upload file ID (for local_file transfer method)."""
+        self._input_file_object_workflow.upload_file_id = upload_file_id
+        return self

dify_oapi/api/workflow/v1/model/node_finished_data.py

@@ -0,0 +1,118 @@
+"""Node finished event data model.
+
+This module defines the data structure for node_finished streaming events.
+"""
+
+from typing import Any, Optional
+
+from pydantic import BaseModel
+
+from .execution_metadata import ExecutionMetadata
+from .workflow_types import NodeStatus, NodeType
+
+
+class NodeFinishedData(BaseModel):
+    """Data structure for node_finished streaming event."""
+
+    id: str
+    node_id: str
+    node_type: NodeType
+    title: str
+    index: int
+    predecessor_node_id: Optional[str] = None
+    inputs: Optional[dict[str, Any]] = None
+    process_data: Optional[dict[str, Any]] = None
+    outputs: Optional[dict[str, Any]] = None
+    status: NodeStatus
+    error: Optional[str] = None
+    elapsed_time: Optional[float] = None
+    execution_metadata: Optional[ExecutionMetadata] = None
+    created_at: int
+
+    @staticmethod
+    def builder() -> "NodeFinishedDataBuilder":
+        """Create a new NodeFinishedData builder."""
+        return NodeFinishedDataBuilder()
+
+
+class NodeFinishedDataBuilder:
+    """Builder for NodeFinishedData."""
+
+    def __init__(self):
+        self._node_finished_data = NodeFinishedData(
+            id="", node_id="", node_type="start", title="", index=0, status="succeeded", created_at=0
+        )
+
+    def build(self) -> NodeFinishedData:
+        """Build the NodeFinishedData instance."""
+        return self._node_finished_data
+
+    def id(self, id: str) -> "NodeFinishedDataBuilder":
+        """Set the node execution ID."""
+        self._node_finished_data.id = id
+        return self
+
+    def node_id(self, node_id: str) -> "NodeFinishedDataBuilder":
+        """Set the node ID."""
+        self._node_finished_data.node_id = node_id
+        return self
+
+    def node_type(self, node_type: NodeType) -> "NodeFinishedDataBuilder":
+        """Set the node type."""
+        self._node_finished_data.node_type = node_type
+        return self
+
+    def title(self, title: str) -> "NodeFinishedDataBuilder":
+        """Set the node title."""
+        self._node_finished_data.title = title
+        return self
+
+    def index(self, index: int) -> "NodeFinishedDataBuilder":
+        """Set the node index."""
+        self._node_finished_data.index = index
+        return self
+
+    def predecessor_node_id(self, predecessor_node_id: str) -> "NodeFinishedDataBuilder":
+        """Set the predecessor node ID."""
+        self._node_finished_data.predecessor_node_id = predecessor_node_id
+        return self
+
+    def inputs(self, inputs: dict[str, Any]) -> "NodeFinishedDataBuilder":
+        """Set the node inputs."""
+        self._node_finished_data.inputs = inputs
+        return self
+
+    def process_data(self, process_data: dict[str, Any]) -> "NodeFinishedDataBuilder":
+        """Set the process data."""
+        self._node_finished_data.process_data = process_data
+        return self
+
+    def outputs(self, outputs: dict[str, Any]) -> "NodeFinishedDataBuilder":
+        """Set the node outputs."""
+        self._node_finished_data.outputs = outputs
+        return self
+
+    def status(self, status: NodeStatus) -> "NodeFinishedDataBuilder":
+        """Set the node status."""
+        self._node_finished_data.status = status
+        return self
+
+    def error(self, error: str) -> "NodeFinishedDataBuilder":
+        """Set the error message."""
+        self._node_finished_data.error = error
+        return self
+
+    def elapsed_time(self, elapsed_time: float) -> "NodeFinishedDataBuilder":
+        """Set the elapsed time."""
+        self._node_finished_data.elapsed_time = elapsed_time
+        return self
+
+    def execution_metadata(self, execution_metadata: ExecutionMetadata) -> "NodeFinishedDataBuilder":
+        """Set the execution metadata."""
+        self._node_finished_data.execution_metadata = execution_metadata
+        return self
+
+    def created_at(self, created_at: int) -> "NodeFinishedDataBuilder":
+        """Set the creation timestamp."""
+        self._node_finished_data.created_at = created_at
+        return self