dify-oapi2 0.2.0__py3-none-any.whl → 0.3.0__py3-none-any.whl

dify_oapi/api/workflow/v1/model/log/log_info.py

@@ -0,0 +1,57 @@
+from __future__ import annotations
+
+from pydantic import BaseModel
+
+from ..workflow.workflow_types import CreatedByRole, CreatedFrom
+from .end_user_info import EndUserInfo
+from .workflow_run_log_info import WorkflowRunLogInfo
+
+
+class LogInfo(BaseModel):
+    id: str | None = None
+    workflow_run: WorkflowRunLogInfo | None = None
+    created_from: CreatedFrom | None = None
+    created_by_role: CreatedByRole | None = None
+    created_by_account: str | None = None
+    created_by_end_user: EndUserInfo | None = None
+    created_at: int | None = None
+
+    @staticmethod
+    def builder() -> LogInfoBuilder:
+        return LogInfoBuilder()
+
+
+class LogInfoBuilder:
+    def __init__(self):
+        self._log_info = LogInfo()
+
+    def build(self) -> LogInfo:
+        return self._log_info
+
+    def id(self, id: str) -> LogInfoBuilder:
+        self._log_info.id = id
+        return self
+
+    def workflow_run(self, workflow_run: WorkflowRunLogInfo) -> LogInfoBuilder:
+        self._log_info.workflow_run = workflow_run
+        return self
+
+    def created_from(self, created_from: CreatedFrom) -> LogInfoBuilder:
+        self._log_info.created_from = created_from
+        return self
+
+    def created_by_role(self, created_by_role: CreatedByRole) -> LogInfoBuilder:
+        self._log_info.created_by_role = created_by_role
+        return self
+
+    def created_by_account(self, created_by_account: str) -> LogInfoBuilder:
+        self._log_info.created_by_account = created_by_account
+        return self
+
+    def created_by_end_user(self, created_by_end_user: EndUserInfo) -> LogInfoBuilder:
+        self._log_info.created_by_end_user = created_by_end_user
+        return self
+
+    def created_at(self, created_at: int) -> LogInfoBuilder:
+        self._log_info.created_at = created_at
+        return self

dify_oapi/api/workflow/v1/model/log/workflow_run_log_info.py

@@ -0,0 +1,65 @@
+from __future__ import annotations
+
+from pydantic import BaseModel
+
+from ..workflow.workflow_types import LogStatus
+
+
+class WorkflowRunLogInfo(BaseModel):
+    id: str | None = None
+    version: str | None = None
+    status: LogStatus | None = None
+    error: str | None = None
+    elapsed_time: float | None = None
+    total_tokens: int | None = None
+    total_steps: int | None = None
+    created_at: int | None = None
+    finished_at: int | None = None
+
+    @staticmethod
+    def builder() -> WorkflowRunLogInfoBuilder:
+        return WorkflowRunLogInfoBuilder()
+
+
+class WorkflowRunLogInfoBuilder:
+    def __init__(self):
+        self._workflow_run_log_info = WorkflowRunLogInfo()
+
+    def build(self) -> WorkflowRunLogInfo:
+        return self._workflow_run_log_info
+
+    def id(self, id: str) -> WorkflowRunLogInfoBuilder:
+        self._workflow_run_log_info.id = id
+        return self
+
+    def version(self, version: str) -> WorkflowRunLogInfoBuilder:
+        self._workflow_run_log_info.version = version
+        return self
+
+    def status(self, status: LogStatus) -> WorkflowRunLogInfoBuilder:
+        self._workflow_run_log_info.status = status
+        return self
+
+    def error(self, error: str) -> WorkflowRunLogInfoBuilder:
+        self._workflow_run_log_info.error = error
+        return self
+
+    def elapsed_time(self, elapsed_time: float) -> WorkflowRunLogInfoBuilder:
+        self._workflow_run_log_info.elapsed_time = elapsed_time
+        return self
+
+    def total_tokens(self, total_tokens: int) -> WorkflowRunLogInfoBuilder:
+        self._workflow_run_log_info.total_tokens = total_tokens
+        return self
+
+    def total_steps(self, total_steps: int) -> WorkflowRunLogInfoBuilder:
+        self._workflow_run_log_info.total_steps = total_steps
+        return self
+
+    def created_at(self, created_at: int) -> WorkflowRunLogInfoBuilder:
+        self._workflow_run_log_info.created_at = created_at
+        return self
+
+    def finished_at(self, finished_at: int) -> WorkflowRunLogInfoBuilder:
+        self._workflow_run_log_info.finished_at = finished_at
+        return self

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

@@ -0,0 +1,33 @@
+from __future__ import annotations
+
+from pydantic import BaseModel
+
+
+class ExecutionMetadata(BaseModel):
+    total_tokens: int | None = None
+    total_price: float | None = None
+    currency: str | None = None
+
+    @staticmethod
+    def builder() -> ExecutionMetadataBuilder:
+        return ExecutionMetadataBuilder()
+
+
+class ExecutionMetadataBuilder:
+    def __init__(self):
+        self._execution_metadata = ExecutionMetadata()
+
+    def build(self) -> ExecutionMetadata:
+        return self._execution_metadata
+
+    def total_tokens(self, total_tokens: int) -> ExecutionMetadataBuilder:
+        self._execution_metadata.total_tokens = total_tokens
+        return self
+
+    def total_price(self, total_price: float) -> ExecutionMetadataBuilder:
+        self._execution_metadata.total_price = total_price
+        return self
+
+    def currency(self, currency: str) -> ExecutionMetadataBuilder:
+        self._execution_metadata.currency = currency
+        return self

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

@@ -0,0 +1,30 @@
+from __future__ import annotations
+
+from dify_oapi.core.enum import HttpMethod
+from dify_oapi.core.model.base_request import BaseRequest
+
+
+class GetWorkflowRunDetailRequest(BaseRequest):
+    def __init__(self) -> None:
+        super().__init__()
+        self.workflow_run_id: str | None = None
+
+    @staticmethod
+    def builder() -> GetWorkflowRunDetailRequestBuilder:
+        return GetWorkflowRunDetailRequestBuilder()
+
+
+class GetWorkflowRunDetailRequestBuilder:
+    def __init__(self):
+        get_workflow_run_detail_request = GetWorkflowRunDetailRequest()
+        get_workflow_run_detail_request.http_method = HttpMethod.GET
+        get_workflow_run_detail_request.uri = "/v1/workflows/run/:workflow_run_id"
+        self._get_workflow_run_detail_request = get_workflow_run_detail_request
+
+    def build(self) -> GetWorkflowRunDetailRequest:
+        return self._get_workflow_run_detail_request
+
+    def workflow_run_id(self, workflow_run_id: str) -> GetWorkflowRunDetailRequestBuilder:
+        self._get_workflow_run_detail_request.workflow_run_id = workflow_run_id
+        self._get_workflow_run_detail_request.paths["workflow_run_id"] = workflow_run_id
+        return self

dify_oapi/api/workflow/v1/model/{run_workflow_response.py → workflow/get_workflow_run_detail_response.py}

@@ -1,24 +1,21 @@
 from __future__ import annotations
 
-from pydantic import BaseModel
+from typing import Any
 
 from dify_oapi.core.model.base_response import BaseResponse
 
+from .workflow_types import WorkflowStatus
 
-class RunWorkflowResponse(BaseResponse):
-    workflow_run_id: str | None = None
-    task_id: str | None = None
-    data: RunWorkflowResponseData | None = None
 
-
-class RunWorkflowResponseData(BaseModel):
+class GetWorkflowRunDetailResponse(BaseResponse):
     id: str | None = None
     workflow_id: str | None = None
-    status: str | None = None
-    outputs: dict | None = None
+    status: WorkflowStatus | None = None
+    inputs: dict[str, Any] | None = None
+    outputs: dict[str, Any] | None = None
     error: str | None = None
-    elapsed_time: float | None = None
-    total_tokens: int | None = None
     total_steps: int | None = None
+    total_tokens: int | None = None
     created_at: int | None = None
     finished_at: int | None = None
+    elapsed_time: float | None = None

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

@@ -0,0 +1,88 @@
+from __future__ import annotations
+
+from typing import Any
+
+from pydantic import BaseModel
+
+from .execution_metadata import ExecutionMetadata
+from .workflow_types import NodeType, WorkflowStatus
+
+
+class NodeInfo(BaseModel):
+    id: str | None = None
+    node_id: str | None = None
+    node_type: NodeType | None = None
+    title: str | None = None
+    index: int | None = None
+    predecessor_node_id: str | None = None
+    inputs: dict[str, Any] | None = None
+    outputs: dict[str, Any] | None = None
+    status: WorkflowStatus | None = None
+    error: str | None = None
+    elapsed_time: float | None = None
+    execution_metadata: ExecutionMetadata | None = None
+    created_at: int | None = None
+
+    @staticmethod
+    def builder() -> NodeInfoBuilder:
+        return NodeInfoBuilder()
+
+
+class NodeInfoBuilder:
+    def __init__(self):
+        self._node_info = NodeInfo()
+
+    def build(self) -> NodeInfo:
+        return self._node_info
+
+    def id(self, id: str) -> NodeInfoBuilder:
+        self._node_info.id = id
+        return self
+
+    def node_id(self, node_id: str) -> NodeInfoBuilder:
+        self._node_info.node_id = node_id
+        return self
+
+    def node_type(self, node_type: NodeType) -> NodeInfoBuilder:
+        self._node_info.node_type = node_type
+        return self
+
+    def title(self, title: str) -> NodeInfoBuilder:
+        self._node_info.title = title
+        return self
+
+    def index(self, index: int) -> NodeInfoBuilder:
+        self._node_info.index = index
+        return self
+
+    def predecessor_node_id(self, predecessor_node_id: str) -> NodeInfoBuilder:
+        self._node_info.predecessor_node_id = predecessor_node_id
+        return self
+
+    def inputs(self, inputs: dict[str, Any]) -> NodeInfoBuilder:
+        self._node_info.inputs = inputs
+        return self
+
+    def outputs(self, outputs: dict[str, Any]) -> NodeInfoBuilder:
+        self._node_info.outputs = outputs
+        return self
+
+    def status(self, status: WorkflowStatus) -> NodeInfoBuilder:
+        self._node_info.status = status
+        return self
+
+    def error(self, error: str) -> NodeInfoBuilder:
+        self._node_info.error = error
+        return self
+
+    def elapsed_time(self, elapsed_time: float) -> NodeInfoBuilder:
+        self._node_info.elapsed_time = elapsed_time
+        return self
+
+    def execution_metadata(self, execution_metadata: ExecutionMetadata) -> NodeInfoBuilder:
+        self._node_info.execution_metadata = execution_metadata
+        return self
+
+    def created_at(self, created_at: int) -> NodeInfoBuilder:
+        self._node_info.created_at = created_at
+        return self

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

@@ -0,0 +1,38 @@
+from __future__ import annotations
+
+from dify_oapi.core.enum import HttpMethod
+from dify_oapi.core.model.base_request import BaseRequest
+
+from .run_specific_workflow_request_body import RunSpecificWorkflowRequestBody
+
+
+class RunSpecificWorkflowRequest(BaseRequest):
+    def __init__(self) -> None:
+        super().__init__()
+        self.workflow_id: str | None = None
+        self.request_body: RunSpecificWorkflowRequestBody | None = None
+
+    @staticmethod
+    def builder() -> RunSpecificWorkflowRequestBuilder:
+        return RunSpecificWorkflowRequestBuilder()
+
+
+class RunSpecificWorkflowRequestBuilder:
+    def __init__(self):
+        run_specific_workflow_request = RunSpecificWorkflowRequest()
+        run_specific_workflow_request.http_method = HttpMethod.POST
+        run_specific_workflow_request.uri = "/v1/workflows/:workflow_id/run"
+        self._run_specific_workflow_request = run_specific_workflow_request
+
+    def build(self) -> RunSpecificWorkflowRequest:
+        return self._run_specific_workflow_request
+
+    def workflow_id(self, workflow_id: str) -> RunSpecificWorkflowRequestBuilder:
+        self._run_specific_workflow_request.workflow_id = workflow_id
+        self._run_specific_workflow_request.paths["workflow_id"] = workflow_id
+        return self
+
+    def request_body(self, request_body: RunSpecificWorkflowRequestBody) -> RunSpecificWorkflowRequestBuilder:
+        self._run_specific_workflow_request.request_body = request_body
+        self._run_specific_workflow_request.body = request_body.model_dump(exclude_none=True, mode="json")
+        return self

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

@@ -0,0 +1,47 @@
+from __future__ import annotations
+
+from pydantic import BaseModel
+
+from .workflow_file_info import WorkflowFileInfo
+from .workflow_inputs import WorkflowInputs
+from .workflow_types import ResponseMode
+
+
+class RunSpecificWorkflowRequestBody(BaseModel):
+    inputs: WorkflowInputs | None = None
+    response_mode: ResponseMode | None = None
+    user: str | None = None
+    files: list[WorkflowFileInfo] | None = None
+    trace_id: str | None = None
+
+    @staticmethod
+    def builder() -> RunSpecificWorkflowRequestBodyBuilder:
+        return RunSpecificWorkflowRequestBodyBuilder()
+
+
+class RunSpecificWorkflowRequestBodyBuilder:
+    def __init__(self):
+        self._run_specific_workflow_request_body = RunSpecificWorkflowRequestBody()
+
+    def build(self) -> RunSpecificWorkflowRequestBody:
+        return self._run_specific_workflow_request_body
+
+    def inputs(self, inputs: WorkflowInputs) -> RunSpecificWorkflowRequestBodyBuilder:
+        self._run_specific_workflow_request_body.inputs = inputs
+        return self
+
+    def response_mode(self, response_mode: ResponseMode) -> RunSpecificWorkflowRequestBodyBuilder:
+        self._run_specific_workflow_request_body.response_mode = response_mode
+        return self
+
+    def user(self, user: str) -> RunSpecificWorkflowRequestBodyBuilder:
+        self._run_specific_workflow_request_body.user = user
+        return self
+
+    def files(self, files: list[WorkflowFileInfo]) -> RunSpecificWorkflowRequestBodyBuilder:
+        self._run_specific_workflow_request_body.files = files
+        return self
+
+    def trace_id(self, trace_id: str) -> RunSpecificWorkflowRequestBodyBuilder:
+        self._run_specific_workflow_request_body.trace_id = trace_id
+        return self

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

@@ -0,0 +1,9 @@
+from __future__ import annotations
+
+from dify_oapi.core.model.base_response import BaseResponse
+
+from .workflow_run_info import WorkflowRunInfo
+
+
+class RunSpecificWorkflowResponse(WorkflowRunInfo, BaseResponse):
+    pass

dify_oapi/api/workflow/v1/model/{run_workflow_request.py → workflow/run_workflow_request.py}

@@ -21,12 +21,12 @@ class RunWorkflowRequestBuilder:
         run_workflow_request = RunWorkflowRequest()
         run_workflow_request.http_method = HttpMethod.POST
         run_workflow_request.uri = "/v1/workflows/run"
-        self._run_workflow_request: RunWorkflowRequest = run_workflow_request
+        self._run_workflow_request = run_workflow_request
+
+    def build(self) -> RunWorkflowRequest:
+        return self._run_workflow_request
 
     def request_body(self, request_body: RunWorkflowRequestBody) -> RunWorkflowRequestBuilder:
         self._run_workflow_request.request_body = request_body
         self._run_workflow_request.body = request_body.model_dump(exclude_none=True, mode="json")
         return self
-
-    def build(self) -> RunWorkflowRequest:
-        return self._run_workflow_request

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

@@ -0,0 +1,47 @@
+from __future__ import annotations
+
+from pydantic import BaseModel
+
+from .workflow_file_info import WorkflowFileInfo
+from .workflow_inputs import WorkflowInputs
+from .workflow_types import ResponseMode
+
+
+class RunWorkflowRequestBody(BaseModel):
+    inputs: WorkflowInputs | None = None
+    response_mode: ResponseMode | None = None
+    user: str | None = None
+    files: list[WorkflowFileInfo] | None = None
+    trace_id: str | None = None
+
+    @staticmethod
+    def builder() -> RunWorkflowRequestBodyBuilder:
+        return RunWorkflowRequestBodyBuilder()
+
+
+class RunWorkflowRequestBodyBuilder:
+    def __init__(self) -> None:
+        self._run_workflow_request_body = RunWorkflowRequestBody()
+
+    def build(self) -> RunWorkflowRequestBody:
+        return self._run_workflow_request_body
+
+    def inputs(self, inputs: WorkflowInputs) -> RunWorkflowRequestBodyBuilder:
+        self._run_workflow_request_body.inputs = inputs
+        return self
+
+    def response_mode(self, response_mode: ResponseMode) -> RunWorkflowRequestBodyBuilder:
+        self._run_workflow_request_body.response_mode = response_mode
+        return self
+
+    def user(self, user: str) -> RunWorkflowRequestBodyBuilder:
+        self._run_workflow_request_body.user = user
+        return self
+
+    def files(self, files: list[WorkflowFileInfo]) -> RunWorkflowRequestBodyBuilder:
+        self._run_workflow_request_body.files = files
+        return self
+
+    def trace_id(self, trace_id: str) -> RunWorkflowRequestBodyBuilder:
+        self._run_workflow_request_body.trace_id = trace_id
+        return self

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

@@ -0,0 +1,9 @@
+from __future__ import annotations
+
+from dify_oapi.core.model.base_response import BaseResponse
+
+from .workflow_run_info import WorkflowRunInfo
+
+
+class RunWorkflowResponse(WorkflowRunInfo, BaseResponse):
+    pass

dify_oapi/api/workflow/v1/model/{stop_workflow_request.py → workflow/stop_workflow_request.py}

@@ -18,21 +18,21 @@ class StopWorkflowRequest(BaseRequest):
 
 
 class StopWorkflowRequestBuilder:
-    def __init__(self) -> None:
-        stop_Workflow_request = StopWorkflowRequest()
-        stop_Workflow_request.http_method = HttpMethod.POST
-        stop_Workflow_request.uri = "/v1/workflows/tasks/:task_id/stop"
-        self._stop_workflow_request: StopWorkflowRequest = stop_Workflow_request
+    def __init__(self):
+        stop_workflow_request = StopWorkflowRequest()
+        stop_workflow_request.http_method = HttpMethod.POST
+        stop_workflow_request.uri = "/v1/workflows/tasks/:task_id/stop"
+        self._stop_workflow_request = stop_workflow_request
+
+    def build(self) -> StopWorkflowRequest:
+        return self._stop_workflow_request
 
     def task_id(self, task_id: str) -> StopWorkflowRequestBuilder:
         self._stop_workflow_request.task_id = task_id
-        self._stop_workflow_request.paths["task_id"] = str(task_id)
+        self._stop_workflow_request.paths["task_id"] = task_id
         return self
 
     def request_body(self, request_body: StopWorkflowRequestBody) -> StopWorkflowRequestBuilder:
         self._stop_workflow_request.request_body = request_body
         self._stop_workflow_request.body = request_body.model_dump(exclude_none=True, mode="json")
         return self
-
-    def build(self) -> StopWorkflowRequest:
-        return self._stop_workflow_request

dify_oapi/api/workflow/v1/model/{stop_workflow_request_body.py → workflow/stop_workflow_request_body.py}

@@ -15,9 +15,9 @@ class StopWorkflowRequestBodyBuilder:
     def __init__(self):
         self._stop_workflow_request_body = StopWorkflowRequestBody()
 
+    def build(self) -> StopWorkflowRequestBody:
+        return self._stop_workflow_request_body
+
     def user(self, user: str) -> StopWorkflowRequestBodyBuilder:
         self._stop_workflow_request_body.user = user
         return self
-
-    def build(self) -> StopWorkflowRequestBody:
-        return self._stop_workflow_request_body

dify_oapi/api/workflow/v1/model/{stop_workflow_response.py → workflow/stop_workflow_response.py}

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 from dify_oapi.core.model.base_response import BaseResponse
 
 

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

@@ -0,0 +1,42 @@
+from __future__ import annotations
+
+from typing import Any
+
+from pydantic import BaseModel
+
+from .workflow_types import EventType
+
+
+class StreamingEvent(BaseModel):
+    event: EventType | None = None
+    task_id: str | None = None
+    workflow_run_id: str | None = None
+    data: dict[str, Any] | None = None
+
+    @staticmethod
+    def builder() -> StreamingEventBuilder:
+        return StreamingEventBuilder()
+
+
+class StreamingEventBuilder:
+    def __init__(self):
+        self._streaming_event = StreamingEvent()
+
+    def build(self) -> StreamingEvent:
+        return self._streaming_event
+
+    def event(self, event: EventType) -> StreamingEventBuilder:
+        self._streaming_event.event = event
+        return self
+
+    def task_id(self, task_id: str) -> StreamingEventBuilder:
+        self._streaming_event.task_id = task_id
+        return self
+
+    def workflow_run_id(self, workflow_run_id: str) -> StreamingEventBuilder:
+        self._streaming_event.workflow_run_id = workflow_run_id
+        return self
+
+    def data(self, data: dict[str, Any]) -> StreamingEventBuilder:
+        self._streaming_event.data = data
+        return self

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

@@ -0,0 +1,40 @@
+from __future__ import annotations
+
+from pydantic import BaseModel
+
+from .workflow_types import FileType, TransferMethod
+
+
+class WorkflowFileInfo(BaseModel):
+    type: FileType | None = None
+    transfer_method: TransferMethod | None = None
+    url: str | None = None
+    upload_file_id: str | None = None
+
+    @staticmethod
+    def builder() -> WorkflowFileInfoBuilder:
+        return WorkflowFileInfoBuilder()
+
+
+class WorkflowFileInfoBuilder:
+    def __init__(self):
+        self._workflow_file_info = WorkflowFileInfo()
+
+    def build(self) -> WorkflowFileInfo:
+        return self._workflow_file_info
+
+    def type(self, type: FileType) -> WorkflowFileInfoBuilder:
+        self._workflow_file_info.type = type
+        return self
+
+    def transfer_method(self, transfer_method: TransferMethod) -> WorkflowFileInfoBuilder:
+        self._workflow_file_info.transfer_method = transfer_method
+        return self
+
+    def url(self, url: str) -> WorkflowFileInfoBuilder:
+        self._workflow_file_info.url = url
+        return self
+
+    def upload_file_id(self, upload_file_id: str) -> WorkflowFileInfoBuilder:
+        self._workflow_file_info.upload_file_id = upload_file_id
+        return self

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

@@ -0,0 +1,56 @@
+from __future__ import annotations
+
+from typing import Union
+
+from pydantic import BaseModel
+
+from .workflow_file_info import WorkflowFileInfo
+
+# Define specific types for workflow input values
+WorkflowInputValue = Union[
+    str,  # Text values
+    int,  # Integer values
+    float,  # Float values
+    bool,  # Boolean values
+    list[WorkflowFileInfo],  # File list type variables
+    list[str],  # String arrays
+    dict[str, Union[str, int, float, bool]],  # Object values
+]
+
+
+class WorkflowInputs(BaseModel):
+    # Dynamic inputs based on workflow configuration
+    # Can contain any key-value pairs defined by the workflow
+    inputs: dict[str, WorkflowInputValue] | None = None
+
+    @staticmethod
+    def builder() -> WorkflowInputsBuilder:
+        return WorkflowInputsBuilder()
+
+    def add_input(self, key: str, value: WorkflowInputValue) -> None:
+        if self.inputs is None:
+            self.inputs = {}
+        self.inputs[key] = value
+
+    def get_input(self, key: str) -> WorkflowInputValue | None:
+        if self.inputs is None:
+            return None
+        return self.inputs.get(key)
+
+
+class WorkflowInputsBuilder:
+    def __init__(self):
+        self._workflow_inputs = WorkflowInputs()
+
+    def build(self) -> WorkflowInputs:
+        return self._workflow_inputs
+
+    def inputs(self, inputs: dict[str, WorkflowInputValue]) -> WorkflowInputsBuilder:
+        self._workflow_inputs.inputs = inputs
+        return self
+
+    def add_input(self, key: str, value: WorkflowInputValue) -> WorkflowInputsBuilder:
+        if self._workflow_inputs.inputs is None:
+            self._workflow_inputs.inputs = {}
+        self._workflow_inputs.inputs[key] = value
+        return self