Initial commit

dify_1.2.0/api/models/__init__.py

@@ -0,0 +1,183 @@
+from .account import (
+    Account,
+    AccountIntegrate,
+    AccountStatus,
+    InvitationCode,
+    Tenant,
+    TenantAccountJoin,
+    TenantAccountRole,
+    TenantStatus,
+)
+from .api_based_extension import APIBasedExtension, APIBasedExtensionPoint
+from .dataset import (
+    AppDatasetJoin,
+    Dataset,
+    DatasetCollectionBinding,
+    DatasetKeywordTable,
+    DatasetPermission,
+    DatasetPermissionEnum,
+    DatasetProcessRule,
+    DatasetQuery,
+    Document,
+    DocumentSegment,
+    Embedding,
+    ExternalKnowledgeApis,
+    ExternalKnowledgeBindings,
+    TidbAuthBinding,
+    Whitelist,
+)
+from .engine import db
+from .enums import CreatedByRole, UserFrom, WorkflowRunTriggeredFrom
+from .model import (
+    ApiRequest,
+    ApiToken,
+    App,
+    AppAnnotationHitHistory,
+    AppAnnotationSetting,
+    AppMode,
+    AppModelConfig,
+    Conversation,
+    DatasetRetrieverResource,
+    DifySetup,
+    EndUser,
+    IconType,
+    InstalledApp,
+    Message,
+    MessageAgentThought,
+    MessageAnnotation,
+    MessageChain,
+    MessageFeedback,
+    MessageFile,
+    OperationLog,
+    RecommendedApp,
+    Site,
+    Tag,
+    TagBinding,
+    TraceAppConfig,
+    UploadFile,
+)
+from .provider import (
+    LoadBalancingModelConfig,
+    Provider,
+    ProviderModel,
+    ProviderModelSetting,
+    ProviderOrder,
+    ProviderQuotaType,
+    ProviderType,
+    TenantDefaultModel,
+    TenantPreferredModelProvider,
+)
+from .source import DataSourceApiKeyAuthBinding, DataSourceOauthBinding
+from .task import CeleryTask, CeleryTaskSet
+from .tools import (
+    ApiToolProvider,
+    BuiltinToolProvider,
+    ToolConversationVariables,
+    ToolFile,
+    ToolLabelBinding,
+    ToolModelInvoke,
+    WorkflowToolProvider,
+)
+from .web import PinnedConversation, SavedMessage
+from .workflow import (
+    ConversationVariable,
+    Workflow,
+    WorkflowAppLog,
+    WorkflowAppLogCreatedFrom,
+    WorkflowNodeExecution,
+    WorkflowNodeExecutionStatus,
+    WorkflowNodeExecutionTriggeredFrom,
+    WorkflowRun,
+    WorkflowRunStatus,
+    WorkflowType,
+)
+
+__all__ = [
+    "APIBasedExtension",
+    "APIBasedExtensionPoint",
+    "Account",
+    "AccountIntegrate",
+    "AccountStatus",
+    "ApiRequest",
+    "ApiToken",
+    "ApiToolProvider",  # Added
+    "App",
+    "AppAnnotationHitHistory",
+    "AppAnnotationSetting",
+    "AppDatasetJoin",
+    "AppMode",
+    "AppModelConfig",
+    "BuiltinToolProvider",  # Added
+    "CeleryTask",
+    "CeleryTaskSet",
+    "Conversation",
+    "ConversationVariable",
+    "CreatedByRole",
+    "DataSourceApiKeyAuthBinding",
+    "DataSourceOauthBinding",
+    "Dataset",
+    "DatasetCollectionBinding",
+    "DatasetKeywordTable",
+    "DatasetPermission",
+    "DatasetPermissionEnum",
+    "DatasetProcessRule",
+    "DatasetQuery",
+    "DatasetRetrieverResource",
+    "DifySetup",
+    "Document",
+    "DocumentSegment",
+    "Embedding",
+    "EndUser",
+    "ExternalKnowledgeApis",
+    "ExternalKnowledgeBindings",
+    "IconType",
+    "InstalledApp",
+    "InvitationCode",
+    "LoadBalancingModelConfig",
+    "Message",
+    "MessageAgentThought",
+    "MessageAnnotation",
+    "MessageChain",
+    "MessageFeedback",
+    "MessageFile",
+    "OperationLog",
+    "PinnedConversation",
+    "Provider",
+    "ProviderModel",
+    "ProviderModelSetting",
+    "ProviderOrder",
+    "ProviderQuotaType",
+    "ProviderType",
+    "RecommendedApp",
+    "SavedMessage",
+    "Site",
+    "Tag",
+    "TagBinding",
+    "Tenant",
+    "TenantAccountJoin",
+    "TenantAccountRole",
+    "TenantDefaultModel",
+    "TenantPreferredModelProvider",
+    "TenantStatus",
+    "TidbAuthBinding",
+    "ToolConversationVariables",
+    "ToolFile",
+    "ToolLabelBinding",
+    "ToolModelInvoke",
+    "TraceAppConfig",
+    "UploadFile",
+    "UserFrom",
+    "Whitelist",
+    "Workflow",
+    "WorkflowAppLog",
+    "WorkflowAppLogCreatedFrom",
+    "WorkflowNodeExecution",
+    "WorkflowNodeExecutionStatus",
+    "WorkflowNodeExecutionTriggeredFrom",
+    "WorkflowRun",
+    "WorkflowRunStatus",
+    "WorkflowRunTriggeredFrom",
+    "WorkflowToolProvider",
+    "WorkflowType",
+    "db",
+]

dify_1.2.0/api/models/account.py

@@ -0,0 +1,300 @@
+import enum
+import json
+
+from flask_login import UserMixin  # type: ignore
+from sqlalchemy import func
+from sqlalchemy.orm import Mapped, mapped_column
+
+from models.base import Base
+
+from .engine import db
+from .types import StringUUID
+
+
+class AccountStatus(enum.StrEnum):
+    PENDING = "pending"
+    UNINITIALIZED = "uninitialized"
+    ACTIVE = "active"
+    BANNED = "banned"
+    CLOSED = "closed"
+
+
+class Account(UserMixin, Base):
+    __tablename__ = "accounts"
+    __table_args__ = (db.PrimaryKeyConstraint("id", name="account_pkey"), db.Index("account_email_idx", "email"))
+
+    id: Mapped[str] = mapped_column(StringUUID, server_default=db.text("uuid_generate_v4()"))
+    name = db.Column(db.String(255), nullable=False)
+    email = db.Column(db.String(255), nullable=False)
+    password = db.Column(db.String(255), nullable=True)
+    password_salt = db.Column(db.String(255), nullable=True)
+    avatar = db.Column(db.String(255))
+    interface_language = db.Column(db.String(255))
+    interface_theme = db.Column(db.String(255))
+    timezone = db.Column(db.String(255))
+    last_login_at = db.Column(db.DateTime)
+    last_login_ip = db.Column(db.String(255))
+    last_active_at = db.Column(db.DateTime, nullable=False, server_default=func.current_timestamp())
+    status = db.Column(db.String(16), nullable=False, server_default=db.text("'active'::character varying"))
+    initialized_at = db.Column(db.DateTime)
+    created_at = db.Column(db.DateTime, nullable=False, server_default=func.current_timestamp())
+    updated_at = db.Column(db.DateTime, nullable=False, server_default=func.current_timestamp())
+
+    @property
+    def is_password_set(self):
+        return self.password is not None
+
+    @property
+    def current_tenant(self):
+        # FIXME: fix the type error later, because the type is important maybe cause some bugs
+        return self._current_tenant  # type: ignore
+
+    @current_tenant.setter
+    def current_tenant(self, value: "Tenant"):
+        tenant = value
+        ta = TenantAccountJoin.query.filter_by(tenant_id=tenant.id, account_id=self.id).first()
+        if ta:
+            tenant.current_role = ta.role
+        else:
+            tenant = None  # type: ignore
+
+        self._current_tenant = tenant
+
+    @property
+    def current_tenant_id(self) -> str | None:
+        return self._current_tenant.id if self._current_tenant else None
+
+    @current_tenant_id.setter
+    def current_tenant_id(self, value: str):
+        try:
+            tenant_account_join = (
+                db.session.query(Tenant, TenantAccountJoin)
+                .filter(Tenant.id == value)
+                .filter(TenantAccountJoin.tenant_id == Tenant.id)
+                .filter(TenantAccountJoin.account_id == self.id)
+                .one_or_none()
+            )
+
+            if tenant_account_join:
+                tenant, ta = tenant_account_join
+                tenant.current_role = ta.role
+            else:
+                tenant = None
+        except Exception:
+            tenant = None
+
+        self._current_tenant = tenant
+
+    @property
+    def current_role(self):
+        return self._current_tenant.current_role
+
+    def get_status(self) -> AccountStatus:
+        status_str = self.status
+        return AccountStatus(status_str)
+
+    @classmethod
+    def get_by_openid(cls, provider: str, open_id: str):
+        account_integrate = (
+            db.session.query(AccountIntegrate)
+            .filter(AccountIntegrate.provider == provider, AccountIntegrate.open_id == open_id)
+            .one_or_none()
+        )
+        if account_integrate:
+            return db.session.query(Account).filter(Account.id == account_integrate.account_id).one_or_none()
+        return None
+
+    # check current_user.current_tenant.current_role in ['admin', 'owner']
+    @property
+    def is_admin_or_owner(self):
+        return TenantAccountRole.is_privileged_role(self._current_tenant.current_role)
+
+    @property
+    def is_admin(self):
+        return TenantAccountRole.is_admin_role(self._current_tenant.current_role)
+
+    @property
+    def is_editor(self):
+        return TenantAccountRole.is_editing_role(self._current_tenant.current_role)
+
+    @property
+    def is_dataset_editor(self):
+        return TenantAccountRole.is_dataset_edit_role(self._current_tenant.current_role)
+
+    @property
+    def is_dataset_operator(self):
+        return self._current_tenant.current_role == TenantAccountRole.DATASET_OPERATOR
+
+
+class TenantStatus(enum.StrEnum):
+    NORMAL = "normal"
+    ARCHIVE = "archive"
+
+
+class TenantAccountRole(enum.StrEnum):
+    OWNER = "owner"
+    ADMIN = "admin"
+    EDITOR = "editor"
+    NORMAL = "normal"
+    DATASET_OPERATOR = "dataset_operator"
+
+    @staticmethod
+    def is_valid_role(role: str) -> bool:
+        if not role:
+            return False
+        return role in {
+            TenantAccountRole.OWNER,
+            TenantAccountRole.ADMIN,
+            TenantAccountRole.EDITOR,
+            TenantAccountRole.NORMAL,
+            TenantAccountRole.DATASET_OPERATOR,
+        }
+
+    @staticmethod
+    def is_privileged_role(role: str) -> bool:
+        if not role:
+            return False
+        return role in {TenantAccountRole.OWNER, TenantAccountRole.ADMIN}
+
+    @staticmethod
+    def is_admin_role(role: str) -> bool:
+        if not role:
+            return False
+        return role == TenantAccountRole.ADMIN
+
+    @staticmethod
+    def is_non_owner_role(role: str) -> bool:
+        if not role:
+            return False
+        return role in {
+            TenantAccountRole.ADMIN,
+            TenantAccountRole.EDITOR,
+            TenantAccountRole.NORMAL,
+            TenantAccountRole.DATASET_OPERATOR,
+        }
+
+    @staticmethod
+    def is_editing_role(role: str) -> bool:
+        if not role:
+            return False
+        return role in {TenantAccountRole.OWNER, TenantAccountRole.ADMIN, TenantAccountRole.EDITOR}
+
+    @staticmethod
+    def is_dataset_edit_role(role: str) -> bool:
+        if not role:
+            return False
+        return role in {
+            TenantAccountRole.OWNER,
+            TenantAccountRole.ADMIN,
+            TenantAccountRole.EDITOR,
+            TenantAccountRole.DATASET_OPERATOR,
+        }
+
+
+class Tenant(db.Model):  # type: ignore[name-defined]
+    __tablename__ = "tenants"
+    __table_args__ = (db.PrimaryKeyConstraint("id", name="tenant_pkey"),)
+
+    id = db.Column(StringUUID, server_default=db.text("uuid_generate_v4()"))
+    name = db.Column(db.String(255), nullable=False)
+    encrypt_public_key = db.Column(db.Text)
+    plan = db.Column(db.String(255), nullable=False, server_default=db.text("'basic'::character varying"))
+    status = db.Column(db.String(255), nullable=False, server_default=db.text("'normal'::character varying"))
+    custom_config = db.Column(db.Text)
+    created_at = db.Column(db.DateTime, nullable=False, server_default=func.current_timestamp())
+    updated_at = db.Column(db.DateTime, nullable=False, server_default=func.current_timestamp())
+
+    def get_accounts(self) -> list[Account]:
+        return (
+            db.session.query(Account)
+            .filter(Account.id == TenantAccountJoin.account_id, TenantAccountJoin.tenant_id == self.id)
+            .all()
+        )
+
+    @property
+    def custom_config_dict(self) -> dict:
+        return json.loads(self.custom_config) if self.custom_config else {}
+
+    @custom_config_dict.setter
+    def custom_config_dict(self, value: dict):
+        self.custom_config = json.dumps(value)
+
+
+class TenantAccountJoin(db.Model):  # type: ignore[name-defined]
+    __tablename__ = "tenant_account_joins"
+    __table_args__ = (
+        db.PrimaryKeyConstraint("id", name="tenant_account_join_pkey"),
+        db.Index("tenant_account_join_account_id_idx", "account_id"),
+        db.Index("tenant_account_join_tenant_id_idx", "tenant_id"),
+        db.UniqueConstraint("tenant_id", "account_id", name="unique_tenant_account_join"),
+    )
+
+    id = db.Column(StringUUID, server_default=db.text("uuid_generate_v4()"))
+    tenant_id = db.Column(StringUUID, nullable=False)
+    account_id = db.Column(StringUUID, nullable=False)
+    current = db.Column(db.Boolean, nullable=False, server_default=db.text("false"))
+    role = db.Column(db.String(16), nullable=False, server_default="normal")
+    invited_by = db.Column(StringUUID, nullable=True)
+    created_at = db.Column(db.DateTime, nullable=False, server_default=func.current_timestamp())
+    updated_at = db.Column(db.DateTime, nullable=False, server_default=func.current_timestamp())
+
+
+class AccountIntegrate(db.Model):  # type: ignore[name-defined]
+    __tablename__ = "account_integrates"
+    __table_args__ = (
+        db.PrimaryKeyConstraint("id", name="account_integrate_pkey"),
+        db.UniqueConstraint("account_id", "provider", name="unique_account_provider"),
+        db.UniqueConstraint("provider", "open_id", name="unique_provider_open_id"),
+    )
+
+    id = db.Column(StringUUID, server_default=db.text("uuid_generate_v4()"))
+    account_id = db.Column(StringUUID, nullable=False)
+    provider = db.Column(db.String(16), nullable=False)
+    open_id = db.Column(db.String(255), nullable=False)
+    encrypted_token = db.Column(db.String(255), nullable=False)
+    created_at = db.Column(db.DateTime, nullable=False, server_default=func.current_timestamp())
+    updated_at = db.Column(db.DateTime, nullable=False, server_default=func.current_timestamp())
+
+
+class InvitationCode(db.Model):  # type: ignore[name-defined]
+    __tablename__ = "invitation_codes"
+    __table_args__ = (
+        db.PrimaryKeyConstraint("id", name="invitation_code_pkey"),
+        db.Index("invitation_codes_batch_idx", "batch"),
+        db.Index("invitation_codes_code_idx", "code", "status"),
+    )
+
+    id = db.Column(db.Integer, nullable=False)
+    batch = db.Column(db.String(255), nullable=False)
+    code = db.Column(db.String(32), nullable=False)
+    status = db.Column(db.String(16), nullable=False, server_default=db.text("'unused'::character varying"))
+    used_at = db.Column(db.DateTime)
+    used_by_tenant_id = db.Column(StringUUID)
+    used_by_account_id = db.Column(StringUUID)
+    deprecated_at = db.Column(db.DateTime)
+    created_at = db.Column(db.DateTime, nullable=False, server_default=db.text("CURRENT_TIMESTAMP(0)"))
+
+
+class TenantPluginPermission(Base):
+    class InstallPermission(enum.StrEnum):
+        EVERYONE = "everyone"
+        ADMINS = "admins"
+        NOBODY = "noone"
+
+    class DebugPermission(enum.StrEnum):
+        EVERYONE = "everyone"
+        ADMINS = "admins"
+        NOBODY = "noone"
+
+    __tablename__ = "account_plugin_permissions"
+    __table_args__ = (
+        db.PrimaryKeyConstraint("id", name="account_plugin_permission_pkey"),
+        db.UniqueConstraint("tenant_id", name="unique_tenant_plugin"),
+    )
+
+    id: Mapped[str] = mapped_column(StringUUID, server_default=db.text("uuid_generate_v4()"))
+    tenant_id: Mapped[str] = mapped_column(StringUUID, nullable=False)
+    install_permission: Mapped[InstallPermission] = mapped_column(
+        db.String(16), nullable=False, server_default="everyone"
+    )
+    debug_permission: Mapped[DebugPermission] = mapped_column(db.String(16), nullable=False, server_default="noone")

dify_1.2.0/api/models/api_based_extension.py

@@ -0,0 +1,28 @@
+import enum
+
+from sqlalchemy import func
+
+from .engine import db
+from .types import StringUUID
+
+
+class APIBasedExtensionPoint(enum.Enum):
+    APP_EXTERNAL_DATA_TOOL_QUERY = "app.external_data_tool.query"
+    PING = "ping"
+    APP_MODERATION_INPUT = "app.moderation.input"
+    APP_MODERATION_OUTPUT = "app.moderation.output"
+
+
+class APIBasedExtension(db.Model):  # type: ignore[name-defined]
+    __tablename__ = "api_based_extensions"
+    __table_args__ = (
+        db.PrimaryKeyConstraint("id", name="api_based_extension_pkey"),
+        db.Index("api_based_extension_tenant_idx", "tenant_id"),
+    )
+
+    id = db.Column(StringUUID, server_default=db.text("uuid_generate_v4()"))
+    tenant_id = db.Column(StringUUID, nullable=False)
+    name = db.Column(db.String(255), nullable=False)
+    api_endpoint = db.Column(db.String(255), nullable=False)
+    api_key = db.Column(db.Text, nullable=False)
+    created_at = db.Column(db.DateTime, nullable=False, server_default=func.current_timestamp())

dify_1.2.0/api/models/base.py

@@ -0,0 +1,5 @@
+from sqlalchemy.orm import declarative_base
+
+from models.engine import metadata
+
+Base = declarative_base(metadata=metadata)

dify_1.2.0/api/models/engine.py

@@ -0,0 +1,13 @@
+from flask_sqlalchemy import SQLAlchemy
+from sqlalchemy import MetaData
+
+POSTGRES_INDEXES_NAMING_CONVENTION = {
+    "ix": "%(column_0_label)s_idx",
+    "uq": "%(table_name)s_%(column_0_name)s_key",
+    "ck": "%(table_name)s_%(constraint_name)s_check",
+    "fk": "%(table_name)s_%(column_0_name)s_fkey",
+    "pk": "%(table_name)s_pkey",
+}
+
+metadata = MetaData(naming_convention=POSTGRES_INDEXES_NAMING_CONVENTION)
+db = SQLAlchemy(metadata=metadata)

dify_1.2.0/api/models/enums.py

@@ -0,0 +1,16 @@
+from enum import StrEnum
+
+
+class CreatedByRole(StrEnum):
+    ACCOUNT = "account"
+    END_USER = "end_user"
+
+
+class UserFrom(StrEnum):
+    ACCOUNT = "account"
+    END_USER = "end-user"
+
+
+class WorkflowRunTriggeredFrom(StrEnum):
+    DEBUGGING = "debugging"
+    APP_RUN = "app-run"

dify_1.2.0/api/models/provider.py

@@ -0,0 +1,217 @@
+from enum import Enum
+
+from sqlalchemy import func
+
+from models.base import Base
+
+from .engine import db
+from .types import StringUUID
+
+
+class ProviderType(Enum):
+    CUSTOM = "custom"
+    SYSTEM = "system"
+
+    @staticmethod
+    def value_of(value):
+        for member in ProviderType:
+            if member.value == value:
+                return member
+        raise ValueError(f"No matching enum found for value '{value}'")
+
+
+class ProviderQuotaType(Enum):
+    PAID = "paid"
+    """hosted paid quota"""
+
+    FREE = "free"
+    """third-party free quota"""
+
+    TRIAL = "trial"
+    """hosted trial quota"""
+
+    @staticmethod
+    def value_of(value):
+        for member in ProviderQuotaType:
+            if member.value == value:
+                return member
+        raise ValueError(f"No matching enum found for value '{value}'")
+
+
+class Provider(Base):
+    """
+    Provider model representing the API providers and their configurations.
+    """
+
+    __tablename__ = "providers"
+    __table_args__ = (
+        db.PrimaryKeyConstraint("id", name="provider_pkey"),
+        db.Index("provider_tenant_id_provider_idx", "tenant_id", "provider_name"),
+        db.UniqueConstraint(
+            "tenant_id", "provider_name", "provider_type", "quota_type", name="unique_provider_name_type_quota"
+        ),
+    )
+
+    id = db.Column(StringUUID, server_default=db.text("uuid_generate_v4()"))
+    tenant_id = db.Column(StringUUID, nullable=False)
+    provider_name = db.Column(db.String(255), nullable=False)
+    provider_type = db.Column(db.String(40), nullable=False, server_default=db.text("'custom'::character varying"))
+    encrypted_config = db.Column(db.Text, nullable=True)
+    is_valid = db.Column(db.Boolean, nullable=False, server_default=db.text("false"))
+    last_used = db.Column(db.DateTime, nullable=True)
+
+    quota_type = db.Column(db.String(40), nullable=True, server_default=db.text("''::character varying"))
+    quota_limit = db.Column(db.BigInteger, nullable=True)
+    quota_used = db.Column(db.BigInteger, default=0)
+
+    created_at = db.Column(db.DateTime, nullable=False, server_default=func.current_timestamp())
+    updated_at = db.Column(db.DateTime, nullable=False, server_default=func.current_timestamp())
+
+    def __repr__(self):
+        return (
+            f"<Provider(id={self.id}, tenant_id={self.tenant_id}, provider_name='{self.provider_name}',"
+            f" provider_type='{self.provider_type}')>"
+        )
+
+    @property
+    def token_is_set(self):
+        """
+        Returns True if the encrypted_config is not None, indicating that the token is set.
+        """
+        return self.encrypted_config is not None
+
+    @property
+    def is_enabled(self):
+        """
+        Returns True if the provider is enabled.
+        """
+        if self.provider_type == ProviderType.SYSTEM.value:
+            return self.is_valid
+        else:
+            return self.is_valid and self.token_is_set
+
+
+class ProviderModel(Base):
+    """
+    Provider model representing the API provider_models and their configurations.
+    """
+
+    __tablename__ = "provider_models"
+    __table_args__ = (
+        db.PrimaryKeyConstraint("id", name="provider_model_pkey"),
+        db.Index("provider_model_tenant_id_provider_idx", "tenant_id", "provider_name"),
+        db.UniqueConstraint(
+            "tenant_id", "provider_name", "model_name", "model_type", name="unique_provider_model_name"
+        ),
+    )
+
+    id = db.Column(StringUUID, server_default=db.text("uuid_generate_v4()"))
+    tenant_id = db.Column(StringUUID, nullable=False)
+    provider_name = db.Column(db.String(255), nullable=False)
+    model_name = db.Column(db.String(255), nullable=False)
+    model_type = db.Column(db.String(40), nullable=False)
+    encrypted_config = db.Column(db.Text, nullable=True)
+    is_valid = db.Column(db.Boolean, nullable=False, server_default=db.text("false"))
+    created_at = db.Column(db.DateTime, nullable=False, server_default=func.current_timestamp())
+    updated_at = db.Column(db.DateTime, nullable=False, server_default=func.current_timestamp())
+
+
+class TenantDefaultModel(Base):
+    __tablename__ = "tenant_default_models"
+    __table_args__ = (
+        db.PrimaryKeyConstraint("id", name="tenant_default_model_pkey"),
+        db.Index("tenant_default_model_tenant_id_provider_type_idx", "tenant_id", "provider_name", "model_type"),
+    )
+
+    id = db.Column(StringUUID, server_default=db.text("uuid_generate_v4()"))
+    tenant_id = db.Column(StringUUID, nullable=False)
+    provider_name = db.Column(db.String(255), nullable=False)
+    model_name = db.Column(db.String(255), nullable=False)
+    model_type = db.Column(db.String(40), nullable=False)
+    created_at = db.Column(db.DateTime, nullable=False, server_default=func.current_timestamp())
+    updated_at = db.Column(db.DateTime, nullable=False, server_default=func.current_timestamp())
+
+
+class TenantPreferredModelProvider(Base):
+    __tablename__ = "tenant_preferred_model_providers"
+    __table_args__ = (
+        db.PrimaryKeyConstraint("id", name="tenant_preferred_model_provider_pkey"),
+        db.Index("tenant_preferred_model_provider_tenant_provider_idx", "tenant_id", "provider_name"),
+    )
+
+    id = db.Column(StringUUID, server_default=db.text("uuid_generate_v4()"))
+    tenant_id = db.Column(StringUUID, nullable=False)
+    provider_name = db.Column(db.String(255), nullable=False)
+    preferred_provider_type = db.Column(db.String(40), nullable=False)
+    created_at = db.Column(db.DateTime, nullable=False, server_default=func.current_timestamp())
+    updated_at = db.Column(db.DateTime, nullable=False, server_default=func.current_timestamp())
+
+
+class ProviderOrder(Base):
+    __tablename__ = "provider_orders"
+    __table_args__ = (
+        db.PrimaryKeyConstraint("id", name="provider_order_pkey"),
+        db.Index("provider_order_tenant_provider_idx", "tenant_id", "provider_name"),
+    )
+
+    id = db.Column(StringUUID, server_default=db.text("uuid_generate_v4()"))
+    tenant_id = db.Column(StringUUID, nullable=False)
+    provider_name = db.Column(db.String(255), nullable=False)
+    account_id = db.Column(StringUUID, nullable=False)
+    payment_product_id = db.Column(db.String(191), nullable=False)
+    payment_id = db.Column(db.String(191))
+    transaction_id = db.Column(db.String(191))
+    quantity = db.Column(db.Integer, nullable=False, server_default=db.text("1"))
+    currency = db.Column(db.String(40))
+    total_amount = db.Column(db.Integer)
+    payment_status = db.Column(db.String(40), nullable=False, server_default=db.text("'wait_pay'::character varying"))
+    paid_at = db.Column(db.DateTime)
+    pay_failed_at = db.Column(db.DateTime)
+    refunded_at = db.Column(db.DateTime)
+    created_at = db.Column(db.DateTime, nullable=False, server_default=func.current_timestamp())
+    updated_at = db.Column(db.DateTime, nullable=False, server_default=func.current_timestamp())
+
+
+class ProviderModelSetting(Base):
+    """
+    Provider model settings for record the model enabled status and load balancing status.
+    """
+
+    __tablename__ = "provider_model_settings"
+    __table_args__ = (
+        db.PrimaryKeyConstraint("id", name="provider_model_setting_pkey"),
+        db.Index("provider_model_setting_tenant_provider_model_idx", "tenant_id", "provider_name", "model_type"),
+    )
+
+    id = db.Column(StringUUID, server_default=db.text("uuid_generate_v4()"))
+    tenant_id = db.Column(StringUUID, nullable=False)
+    provider_name = db.Column(db.String(255), nullable=False)
+    model_name = db.Column(db.String(255), nullable=False)
+    model_type = db.Column(db.String(40), nullable=False)
+    enabled = db.Column(db.Boolean, nullable=False, server_default=db.text("true"))
+    load_balancing_enabled = db.Column(db.Boolean, nullable=False, server_default=db.text("false"))
+    created_at = db.Column(db.DateTime, nullable=False, server_default=func.current_timestamp())
+    updated_at = db.Column(db.DateTime, nullable=False, server_default=func.current_timestamp())
+
+
+class LoadBalancingModelConfig(Base):
+    """
+    Configurations for load balancing models.
+    """
+
+    __tablename__ = "load_balancing_model_configs"
+    __table_args__ = (
+        db.PrimaryKeyConstraint("id", name="load_balancing_model_config_pkey"),
+        db.Index("load_balancing_model_config_tenant_provider_model_idx", "tenant_id", "provider_name", "model_type"),
+    )
+
+    id = db.Column(StringUUID, server_default=db.text("uuid_generate_v4()"))
+    tenant_id = db.Column(StringUUID, nullable=False)
+    provider_name = db.Column(db.String(255), nullable=False)
+    model_name = db.Column(db.String(255), nullable=False)
+    model_type = db.Column(db.String(40), nullable=False)
+    name = db.Column(db.String(255), nullable=False)
+    encrypted_config = db.Column(db.Text, nullable=True)
+    enabled = db.Column(db.Boolean, nullable=False, server_default=db.text("true"))
+    created_at = db.Column(db.DateTime, nullable=False, server_default=func.current_timestamp())
+    updated_at = db.Column(db.DateTime, nullable=False, server_default=func.current_timestamp())

dify_1.2.0/api/models/source.py

@@ -0,0 +1,57 @@
+import json
+
+from sqlalchemy import func
+from sqlalchemy.dialects.postgresql import JSONB
+
+from models.base import Base
+
+from .engine import db
+from .types import StringUUID
+
+
+class DataSourceOauthBinding(db.Model):  # type: ignore[name-defined]
+    __tablename__ = "data_source_oauth_bindings"
+    __table_args__ = (
+        db.PrimaryKeyConstraint("id", name="source_binding_pkey"),
+        db.Index("source_binding_tenant_id_idx", "tenant_id"),
+        db.Index("source_info_idx", "source_info", postgresql_using="gin"),
+    )
+
+    id = db.Column(StringUUID, server_default=db.text("uuid_generate_v4()"))
+    tenant_id = db.Column(StringUUID, nullable=False)
+    access_token = db.Column(db.String(255), nullable=False)
+    provider = db.Column(db.String(255), nullable=False)
+    source_info = db.Column(JSONB, nullable=False)
+    created_at = db.Column(db.DateTime, nullable=False, server_default=func.current_timestamp())
+    updated_at = db.Column(db.DateTime, nullable=False, server_default=func.current_timestamp())
+    disabled = db.Column(db.Boolean, nullable=True, server_default=db.text("false"))
+
+
+class DataSourceApiKeyAuthBinding(Base):
+    __tablename__ = "data_source_api_key_auth_bindings"
+    __table_args__ = (
+        db.PrimaryKeyConstraint("id", name="data_source_api_key_auth_binding_pkey"),
+        db.Index("data_source_api_key_auth_binding_tenant_id_idx", "tenant_id"),
+        db.Index("data_source_api_key_auth_binding_provider_idx", "provider"),
+    )
+
+    id = db.Column(StringUUID, server_default=db.text("uuid_generate_v4()"))
+    tenant_id = db.Column(StringUUID, nullable=False)
+    category = db.Column(db.String(255), nullable=False)
+    provider = db.Column(db.String(255), nullable=False)
+    credentials = db.Column(db.Text, nullable=True)  # JSON
+    created_at = db.Column(db.DateTime, nullable=False, server_default=func.current_timestamp())
+    updated_at = db.Column(db.DateTime, nullable=False, server_default=func.current_timestamp())
+    disabled = db.Column(db.Boolean, nullable=True, server_default=db.text("false"))
+
+    def to_dict(self):
+        return {
+            "id": self.id,
+            "tenant_id": self.tenant_id,
+            "category": self.category,
+            "provider": self.provider,
+            "credentials": json.loads(self.credentials),
+            "created_at": self.created_at.timestamp(),
+            "updated_at": self.updated_at.timestamp(),
+            "disabled": self.disabled,
+        }

dify_1.2.0/api/models/task.py

@@ -0,0 +1,42 @@
+from datetime import UTC, datetime
+
+from celery import states  # type: ignore
+
+from models.base import Base
+
+from .engine import db
+
+
+class CeleryTask(Base):
+    """Task result/status."""
+
+    __tablename__ = "celery_taskmeta"
+
+    id = db.Column(db.Integer, db.Sequence("task_id_sequence"), primary_key=True, autoincrement=True)
+    task_id = db.Column(db.String(155), unique=True)
+    status = db.Column(db.String(50), default=states.PENDING)
+    result = db.Column(db.PickleType, nullable=True)
+    date_done = db.Column(
+        db.DateTime,
+        default=lambda: datetime.now(UTC).replace(tzinfo=None),
+        onupdate=lambda: datetime.now(UTC).replace(tzinfo=None),
+        nullable=True,
+    )
+    traceback = db.Column(db.Text, nullable=True)
+    name = db.Column(db.String(155), nullable=True)
+    args = db.Column(db.LargeBinary, nullable=True)
+    kwargs = db.Column(db.LargeBinary, nullable=True)
+    worker = db.Column(db.String(155), nullable=True)
+    retries = db.Column(db.Integer, nullable=True)
+    queue = db.Column(db.String(155), nullable=True)
+
+
+class CeleryTaskSet(Base):
+    """TaskSet result."""
+
+    __tablename__ = "celery_tasksetmeta"
+
+    id = db.Column(db.Integer, db.Sequence("taskset_id_sequence"), autoincrement=True, primary_key=True)
+    taskset_id = db.Column(db.String(155), unique=True)
+    result = db.Column(db.PickleType, nullable=True)
+    date_done = db.Column(db.DateTime, default=lambda: datetime.now(UTC).replace(tzinfo=None), nullable=True)

dify_1.2.0/api/models/tools.py

@@ -0,0 +1,358 @@
+import json
+from datetime import datetime
+from typing import Any, Optional, cast
+
+import sqlalchemy as sa
+from deprecated import deprecated
+from sqlalchemy import ForeignKey, func
+from sqlalchemy.orm import Mapped, mapped_column
+
+from core.tools.entities.common_entities import I18nObject
+from core.tools.entities.tool_bundle import ApiToolBundle
+from core.tools.entities.tool_entities import ApiProviderSchemaType, WorkflowToolParameterConfiguration
+from models.base import Base
+
+from .engine import db
+from .model import Account, App, Tenant
+from .types import StringUUID
+
+
+class BuiltinToolProvider(Base):
+    """
+    This table stores the tool provider information for built-in tools for each tenant.
+    """
+
+    __tablename__ = "tool_builtin_providers"
+    __table_args__ = (
+        db.PrimaryKeyConstraint("id", name="tool_builtin_provider_pkey"),
+        # one tenant can only have one tool provider with the same name
+        db.UniqueConstraint("tenant_id", "provider", name="unique_builtin_tool_provider"),
+    )
+
+    # id of the tool provider
+    id: Mapped[str] = mapped_column(StringUUID, server_default=db.text("uuid_generate_v4()"))
+    # id of the tenant
+    tenant_id: Mapped[str] = mapped_column(StringUUID, nullable=True)
+    # who created this tool provider
+    user_id: Mapped[str] = mapped_column(StringUUID, nullable=False)
+    # name of the tool provider
+    provider: Mapped[str] = mapped_column(db.String(256), nullable=False)
+    # credential of the tool provider
+    encrypted_credentials: Mapped[str] = mapped_column(db.Text, nullable=True)
+    created_at: Mapped[datetime] = mapped_column(
+        db.DateTime, nullable=False, server_default=db.text("CURRENT_TIMESTAMP(0)")
+    )
+    updated_at: Mapped[datetime] = mapped_column(
+        db.DateTime, nullable=False, server_default=db.text("CURRENT_TIMESTAMP(0)")
+    )
+
+    @property
+    def credentials(self) -> dict:
+        return cast(dict, json.loads(self.encrypted_credentials))
+
+
+class ApiToolProvider(Base):
+    """
+    The table stores the api providers.
+    """
+
+    __tablename__ = "tool_api_providers"
+    __table_args__ = (
+        db.PrimaryKeyConstraint("id", name="tool_api_provider_pkey"),
+        db.UniqueConstraint("name", "tenant_id", name="unique_api_tool_provider"),
+    )
+
+    id = db.Column(StringUUID, server_default=db.text("uuid_generate_v4()"))
+    # name of the api provider
+    name = db.Column(db.String(255), nullable=False)
+    # icon
+    icon = db.Column(db.String(255), nullable=False)
+    # original schema
+    schema = db.Column(db.Text, nullable=False)
+    schema_type_str: Mapped[str] = db.Column(db.String(40), nullable=False)
+    # who created this tool
+    user_id = db.Column(StringUUID, nullable=False)
+    # tenant id
+    tenant_id = db.Column(StringUUID, nullable=False)
+    # description of the provider
+    description = db.Column(db.Text, nullable=False)
+    # json format tools
+    tools_str = db.Column(db.Text, nullable=False)
+    # json format credentials
+    credentials_str = db.Column(db.Text, nullable=False)
+    # privacy policy
+    privacy_policy = db.Column(db.String(255), nullable=True)
+    # custom_disclaimer
+    custom_disclaimer: Mapped[str] = mapped_column(sa.TEXT, default="")
+
+    created_at: Mapped[datetime] = mapped_column(db.DateTime, nullable=False, server_default=func.current_timestamp())
+    updated_at: Mapped[datetime] = mapped_column(db.DateTime, nullable=False, server_default=func.current_timestamp())
+
+    @property
+    def schema_type(self) -> ApiProviderSchemaType:
+        return ApiProviderSchemaType.value_of(self.schema_type_str)
+
+    @property
+    def tools(self) -> list[ApiToolBundle]:
+        return [ApiToolBundle(**tool) for tool in json.loads(self.tools_str)]
+
+    @property
+    def credentials(self) -> dict:
+        return dict(json.loads(self.credentials_str))
+
+    @property
+    def user(self) -> Account | None:
+        if not self.user_id:
+            return None
+        return db.session.query(Account).filter(Account.id == self.user_id).first()
+
+    @property
+    def tenant(self) -> Tenant | None:
+        return db.session.query(Tenant).filter(Tenant.id == self.tenant_id).first()
+
+
+class ToolLabelBinding(Base):
+    """
+    The table stores the labels for tools.
+    """
+
+    __tablename__ = "tool_label_bindings"
+    __table_args__ = (
+        db.PrimaryKeyConstraint("id", name="tool_label_bind_pkey"),
+        db.UniqueConstraint("tool_id", "label_name", name="unique_tool_label_bind"),
+    )
+
+    id: Mapped[str] = mapped_column(StringUUID, server_default=db.text("uuid_generate_v4()"))
+    # tool id
+    tool_id: Mapped[str] = mapped_column(db.String(64), nullable=False)
+    # tool type
+    tool_type: Mapped[str] = mapped_column(db.String(40), nullable=False)
+    # label name
+    label_name: Mapped[str] = mapped_column(db.String(40), nullable=False)
+
+
+class WorkflowToolProvider(Base):
+    """
+    The table stores the workflow providers.
+    """
+
+    __tablename__ = "tool_workflow_providers"
+    __table_args__ = (
+        db.PrimaryKeyConstraint("id", name="tool_workflow_provider_pkey"),
+        db.UniqueConstraint("name", "tenant_id", name="unique_workflow_tool_provider"),
+        db.UniqueConstraint("tenant_id", "app_id", name="unique_workflow_tool_provider_app_id"),
+    )
+
+    id: Mapped[str] = mapped_column(StringUUID, server_default=db.text("uuid_generate_v4()"))
+    # name of the workflow provider
+    name: Mapped[str] = mapped_column(db.String(255), nullable=False)
+    # label of the workflow provider
+    label: Mapped[str] = mapped_column(db.String(255), nullable=False, server_default="")
+    # icon
+    icon: Mapped[str] = mapped_column(db.String(255), nullable=False)
+    # app id of the workflow provider
+    app_id: Mapped[str] = mapped_column(StringUUID, nullable=False)
+    # version of the workflow provider
+    version: Mapped[str] = mapped_column(db.String(255), nullable=False, server_default="")
+    # who created this tool
+    user_id: Mapped[str] = mapped_column(StringUUID, nullable=False)
+    # tenant id
+    tenant_id: Mapped[str] = mapped_column(StringUUID, nullable=False)
+    # description of the provider
+    description: Mapped[str] = mapped_column(db.Text, nullable=False)
+    # parameter configuration
+    parameter_configuration: Mapped[str] = mapped_column(db.Text, nullable=False, server_default="[]")
+    # privacy policy
+    privacy_policy: Mapped[str] = mapped_column(db.String(255), nullable=True, server_default="")
+
+    created_at: Mapped[datetime] = mapped_column(
+        db.DateTime, nullable=False, server_default=db.text("CURRENT_TIMESTAMP(0)")
+    )
+    updated_at: Mapped[datetime] = mapped_column(
+        db.DateTime, nullable=False, server_default=db.text("CURRENT_TIMESTAMP(0)")
+    )
+
+    @property
+    def schema_type(self) -> ApiProviderSchemaType:
+        return ApiProviderSchemaType.value_of(self.schema_type_str)
+
+    @property
+    def user(self) -> Account | None:
+        return db.session.query(Account).filter(Account.id == self.user_id).first()
+
+    @property
+    def tenant(self) -> Tenant | None:
+        return db.session.query(Tenant).filter(Tenant.id == self.tenant_id).first()
+
+    @property
+    def parameter_configurations(self) -> list[WorkflowToolParameterConfiguration]:
+        return [WorkflowToolParameterConfiguration(**config) for config in json.loads(self.parameter_configuration)]
+
+    @property
+    def app(self) -> App | None:
+        return db.session.query(App).filter(App.id == self.app_id).first()
+
+
+class ToolModelInvoke(Base):
+    """
+    store the invoke logs from tool invoke
+    """
+
+    __tablename__ = "tool_model_invokes"
+    __table_args__ = (db.PrimaryKeyConstraint("id", name="tool_model_invoke_pkey"),)
+
+    id = db.Column(StringUUID, server_default=db.text("uuid_generate_v4()"))
+    # who invoke this tool
+    user_id = db.Column(StringUUID, nullable=False)
+    # tenant id
+    tenant_id = db.Column(StringUUID, nullable=False)
+    # provider
+    provider = db.Column(db.String(255), nullable=False)
+    # type
+    tool_type = db.Column(db.String(40), nullable=False)
+    # tool name
+    tool_name = db.Column(db.String(40), nullable=False)
+    # invoke parameters
+    model_parameters = db.Column(db.Text, nullable=False)
+    # prompt messages
+    prompt_messages = db.Column(db.Text, nullable=False)
+    # invoke response
+    model_response = db.Column(db.Text, nullable=False)
+
+    prompt_tokens = db.Column(db.Integer, nullable=False, server_default=db.text("0"))
+    answer_tokens = db.Column(db.Integer, nullable=False, server_default=db.text("0"))
+    answer_unit_price = db.Column(db.Numeric(10, 4), nullable=False)
+    answer_price_unit = db.Column(db.Numeric(10, 7), nullable=False, server_default=db.text("0.001"))
+    provider_response_latency = db.Column(db.Float, nullable=False, server_default=db.text("0"))
+    total_price = db.Column(db.Numeric(10, 7))
+    currency = db.Column(db.String(255), nullable=False)
+    created_at = db.Column(db.DateTime, nullable=False, server_default=func.current_timestamp())
+    updated_at = db.Column(db.DateTime, nullable=False, server_default=func.current_timestamp())
+
+
+@deprecated
+class ToolConversationVariables(Base):
+    """
+    store the conversation variables from tool invoke
+    """
+
+    __tablename__ = "tool_conversation_variables"
+    __table_args__ = (
+        db.PrimaryKeyConstraint("id", name="tool_conversation_variables_pkey"),
+        # add index for user_id and conversation_id
+        db.Index("user_id_idx", "user_id"),
+        db.Index("conversation_id_idx", "conversation_id"),
+    )
+
+    id = db.Column(StringUUID, server_default=db.text("uuid_generate_v4()"))
+    # conversation user id
+    user_id = db.Column(StringUUID, nullable=False)
+    # tenant id
+    tenant_id = db.Column(StringUUID, nullable=False)
+    # conversation id
+    conversation_id = db.Column(StringUUID, nullable=False)
+    # variables pool
+    variables_str = db.Column(db.Text, nullable=False)
+
+    created_at = db.Column(db.DateTime, nullable=False, server_default=func.current_timestamp())
+    updated_at = db.Column(db.DateTime, nullable=False, server_default=func.current_timestamp())
+
+    @property
+    def variables(self) -> Any:
+        return json.loads(self.variables_str)
+
+
+class ToolFile(Base):
+    """
+    store the file created by agent
+    """
+
+    __tablename__ = "tool_files"
+    __table_args__ = (
+        db.PrimaryKeyConstraint("id", name="tool_file_pkey"),
+        db.Index("tool_file_conversation_id_idx", "conversation_id"),
+    )
+
+    id: Mapped[str] = mapped_column(StringUUID, server_default=db.text("uuid_generate_v4()"))
+    # conversation user id
+    user_id: Mapped[str] = mapped_column(StringUUID)
+    # tenant id
+    tenant_id: Mapped[str] = mapped_column(StringUUID)
+    # conversation id
+    conversation_id: Mapped[str] = mapped_column(StringUUID, nullable=True)
+    # file key
+    file_key: Mapped[str] = mapped_column(db.String(255), nullable=False)
+    # mime type
+    mimetype: Mapped[str] = mapped_column(db.String(255), nullable=False)
+    # original url
+    original_url: Mapped[str] = mapped_column(db.String(2048), nullable=True)
+    # name
+    name: Mapped[str] = mapped_column(default="")
+    # size
+    size: Mapped[int] = mapped_column(default=-1)
+
+
+@deprecated
+class DeprecatedPublishedAppTool(Base):
+    """
+    The table stores the apps published as a tool for each person.
+    """
+
+    __tablename__ = "tool_published_apps"
+    __table_args__ = (
+        db.PrimaryKeyConstraint("id", name="published_app_tool_pkey"),
+        db.UniqueConstraint("app_id", "user_id", name="unique_published_app_tool"),
+    )
+
+    # id of the app
+    app_id = db.Column(StringUUID, ForeignKey("apps.id"), nullable=False)
+    # who published this tool
+    description = db.Column(db.Text, nullable=False)
+    # llm_description of the tool, for LLM
+    llm_description = db.Column(db.Text, nullable=False)
+    # query description, query will be seem as a parameter of the tool,
+    # to describe this parameter to llm, we need this field
+    query_description = db.Column(db.Text, nullable=False)
+    # query name, the name of the query parameter
+    query_name = db.Column(db.String(40), nullable=False)
+    # name of the tool provider
+    tool_name = db.Column(db.String(40), nullable=False)
+    # author
+    author = db.Column(db.String(40), nullable=False)
+    created_at = db.Column(db.DateTime, nullable=False, server_default=db.text("CURRENT_TIMESTAMP(0)"))
+    updated_at = db.Column(db.DateTime, nullable=False, server_default=db.text("CURRENT_TIMESTAMP(0)"))
+
+    @property
+    def description_i18n(self) -> I18nObject:
+        return I18nObject(**json.loads(self.description))
+
+    id = db.Column(StringUUID, server_default=db.text("uuid_generate_v4()"))
+    user_id: Mapped[str] = db.Column(StringUUID, nullable=False)
+    tenant_id: Mapped[str] = db.Column(StringUUID, nullable=False)
+    conversation_id: Mapped[Optional[str]] = db.Column(StringUUID, nullable=True)
+    file_key: Mapped[str] = db.Column(db.String(255), nullable=False)
+    mimetype: Mapped[str] = db.Column(db.String(255), nullable=False)
+    original_url: Mapped[Optional[str]] = db.Column(db.String(2048), nullable=True)
+    name: Mapped[str] = mapped_column(default="")
+    size: Mapped[int] = mapped_column(default=-1)
+
+    def __init__(
+        self,
+        *,
+        user_id: str,
+        tenant_id: str,
+        conversation_id: Optional[str] = None,
+        file_key: str,
+        mimetype: str,
+        original_url: Optional[str] = None,
+        name: str,
+        size: int,
+    ):
+        self.user_id = user_id
+        self.tenant_id = tenant_id
+        self.conversation_id = conversation_id
+        self.file_key = file_key
+        self.mimetype = mimetype
+        self.original_url = original_url
+        self.name = name
+        self.size = size

dify_1.2.0/api/models/types.py

@@ -0,0 +1,26 @@
+from sqlalchemy import CHAR, TypeDecorator
+from sqlalchemy.dialects.postgresql import UUID
+
+
+class StringUUID(TypeDecorator):
+    impl = CHAR
+    cache_ok = True
+
+    def process_bind_param(self, value, dialect):
+        if value is None:
+            return value
+        elif dialect.name == "postgresql":
+            return str(value)
+        else:
+            return value.hex
+
+    def load_dialect_impl(self, dialect):
+        if dialect.name == "postgresql":
+            return dialect.type_descriptor(UUID())
+        else:
+            return dialect.type_descriptor(CHAR(36))
+
+    def process_result_value(self, value, dialect):
+        if value is None:
+            return value
+        return str(value)

dify_1.2.0/api/models/web.py

@@ -0,0 +1,42 @@
+from sqlalchemy import func
+from sqlalchemy.orm import Mapped, mapped_column
+
+from models.base import Base
+
+from .engine import db
+from .model import Message
+from .types import StringUUID
+
+
+class SavedMessage(Base):
+    __tablename__ = "saved_messages"
+    __table_args__ = (
+        db.PrimaryKeyConstraint("id", name="saved_message_pkey"),
+        db.Index("saved_message_message_idx", "app_id", "message_id", "created_by_role", "created_by"),
+    )
+
+    id = db.Column(StringUUID, server_default=db.text("uuid_generate_v4()"))
+    app_id = db.Column(StringUUID, nullable=False)
+    message_id = db.Column(StringUUID, nullable=False)
+    created_by_role = db.Column(db.String(255), nullable=False, server_default=db.text("'end_user'::character varying"))
+    created_by = db.Column(StringUUID, nullable=False)
+    created_at = db.Column(db.DateTime, nullable=False, server_default=func.current_timestamp())
+
+    @property
+    def message(self):
+        return db.session.query(Message).filter(Message.id == self.message_id).first()
+
+
+class PinnedConversation(Base):
+    __tablename__ = "pinned_conversations"
+    __table_args__ = (
+        db.PrimaryKeyConstraint("id", name="pinned_conversation_pkey"),
+        db.Index("pinned_conversation_conversation_idx", "app_id", "conversation_id", "created_by_role", "created_by"),
+    )
+
+    id = db.Column(StringUUID, server_default=db.text("uuid_generate_v4()"))
+    app_id = db.Column(StringUUID, nullable=False)
+    conversation_id: Mapped[str] = mapped_column(StringUUID)
+    created_by_role = db.Column(db.String(255), nullable=False, server_default=db.text("'end_user'::character varying"))
+    created_by = db.Column(StringUUID, nullable=False)
+    created_at = db.Column(db.DateTime, nullable=False, server_default=func.current_timestamp())

dify_1.2.0/api/models/workflow.py

@@ -0,0 +1,824 @@
+import json
+from collections.abc import Mapping, Sequence
+from datetime import UTC, datetime
+from enum import Enum
+from typing import TYPE_CHECKING, Any, Optional, Self, Union
+from uuid import uuid4
+
+if TYPE_CHECKING:
+    from models.model import AppMode
+from enum import StrEnum
+from typing import TYPE_CHECKING
+
+import sqlalchemy as sa
+from sqlalchemy import Index, PrimaryKeyConstraint, func
+from sqlalchemy.orm import Mapped, mapped_column
+
+import contexts
+from constants import HIDDEN_VALUE
+from core.helper import encrypter
+from core.variables import SecretVariable, Variable
+from factories import variable_factory
+from libs import helper
+from models.base import Base
+from models.enums import CreatedByRole
+
+from .account import Account
+from .engine import db
+from .types import StringUUID
+
+if TYPE_CHECKING:
+    from models.model import AppMode
+
+
+class WorkflowType(Enum):
+    """
+    Workflow Type Enum
+    """
+
+    WORKFLOW = "workflow"
+    CHAT = "chat"
+
+    @classmethod
+    def value_of(cls, value: str) -> "WorkflowType":
+        """
+        Get value of given mode.
+
+        :param value: mode value
+        :return: mode
+        """
+        for mode in cls:
+            if mode.value == value:
+                return mode
+        raise ValueError(f"invalid workflow type value {value}")
+
+    @classmethod
+    def from_app_mode(cls, app_mode: Union[str, "AppMode"]) -> "WorkflowType":
+        """
+        Get workflow type from app mode.
+
+        :param app_mode: app mode
+        :return: workflow type
+        """
+        from models.model import AppMode
+
+        app_mode = app_mode if isinstance(app_mode, AppMode) else AppMode.value_of(app_mode)
+        return cls.WORKFLOW if app_mode == AppMode.WORKFLOW else cls.CHAT
+
+
+class Workflow(Base):
+    """
+    Workflow, for `Workflow App` and `Chat App workflow mode`.
+
+    Attributes:
+
+    - id (uuid) Workflow ID, pk
+    - tenant_id (uuid) Workspace ID
+    - app_id (uuid) App ID
+    - type (string) Workflow type
+
+        `workflow` for `Workflow App`
+
+        `chat` for `Chat App workflow mode`
+
+    - version (string) Version
+
+        `draft` for draft version (only one for each app), other for version number (redundant)
+
+    - graph (text) Workflow canvas configuration (JSON)
+
+        The entire canvas configuration JSON, including Node, Edge, and other configurations
+
+        - nodes (array[object]) Node list, see Node Schema
+
+        - edges (array[object]) Edge list, see Edge Schema
+
+    - created_by (uuid) Creator ID
+    - created_at (timestamp) Creation time
+    - updated_by (uuid) `optional` Last updater ID
+    - updated_at (timestamp) `optional` Last update time
+    """
+
+    __tablename__ = "workflows"
+    __table_args__ = (
+        db.PrimaryKeyConstraint("id", name="workflow_pkey"),
+        db.Index("workflow_version_idx", "tenant_id", "app_id", "version"),
+    )
+
+    id: Mapped[str] = mapped_column(StringUUID, server_default=db.text("uuid_generate_v4()"))
+    tenant_id: Mapped[str] = mapped_column(StringUUID, nullable=False)
+    app_id: Mapped[str] = mapped_column(StringUUID, nullable=False)
+    type: Mapped[str] = mapped_column(db.String(255), nullable=False)
+    version: Mapped[str] = mapped_column(db.String(255), nullable=False)
+    marked_name: Mapped[str] = mapped_column(default="", server_default="")
+    marked_comment: Mapped[str] = mapped_column(default="", server_default="")
+    graph: Mapped[str] = mapped_column(sa.Text)
+    _features: Mapped[str] = mapped_column("features", sa.TEXT)
+    created_by: Mapped[str] = mapped_column(StringUUID, nullable=False)
+    created_at: Mapped[datetime] = mapped_column(db.DateTime, nullable=False, server_default=func.current_timestamp())
+    updated_by: Mapped[Optional[str]] = mapped_column(StringUUID)
+    updated_at: Mapped[datetime] = mapped_column(
+        db.DateTime,
+        nullable=False,
+        default=datetime.now(UTC).replace(tzinfo=None),
+        server_onupdate=func.current_timestamp(),
+    )
+    _environment_variables: Mapped[str] = mapped_column(
+        "environment_variables", db.Text, nullable=False, server_default="{}"
+    )
+    _conversation_variables: Mapped[str] = mapped_column(
+        "conversation_variables", db.Text, nullable=False, server_default="{}"
+    )
+
+    @classmethod
+    def new(
+        cls,
+        *,
+        tenant_id: str,
+        app_id: str,
+        type: str,
+        version: str,
+        graph: str,
+        features: str,
+        created_by: str,
+        environment_variables: Sequence[Variable],
+        conversation_variables: Sequence[Variable],
+        marked_name: str = "",
+        marked_comment: str = "",
+    ) -> Self:
+        workflow = Workflow()
+        workflow.id = str(uuid4())
+        workflow.tenant_id = tenant_id
+        workflow.app_id = app_id
+        workflow.type = type
+        workflow.version = version
+        workflow.graph = graph
+        workflow.features = features
+        workflow.created_by = created_by
+        workflow.environment_variables = environment_variables or []
+        workflow.conversation_variables = conversation_variables or []
+        workflow.marked_name = marked_name
+        workflow.marked_comment = marked_comment
+        workflow.created_at = datetime.now(UTC).replace(tzinfo=None)
+        workflow.updated_at = workflow.created_at
+        return workflow
+
+    @property
+    def created_by_account(self):
+        return db.session.get(Account, self.created_by)
+
+    @property
+    def updated_by_account(self):
+        return db.session.get(Account, self.updated_by) if self.updated_by else None
+
+    @property
+    def graph_dict(self) -> Mapping[str, Any]:
+        return json.loads(self.graph) if self.graph else {}
+
+    @property
+    def features(self) -> str:
+        """
+        Convert old features structure to new features structure.
+        """
+        if not self._features:
+            return self._features
+
+        features = json.loads(self._features)
+        if features.get("file_upload", {}).get("image", {}).get("enabled", False):
+            image_enabled = True
+            image_number_limits = int(features["file_upload"]["image"].get("number_limits", 1))
+            image_transfer_methods = features["file_upload"]["image"].get(
+                "transfer_methods", ["remote_url", "local_file"]
+            )
+            features["file_upload"]["enabled"] = image_enabled
+            features["file_upload"]["number_limits"] = image_number_limits
+            features["file_upload"]["allowed_file_upload_methods"] = image_transfer_methods
+            features["file_upload"]["allowed_file_types"] = features["file_upload"].get("allowed_file_types", ["image"])
+            features["file_upload"]["allowed_file_extensions"] = []
+            del features["file_upload"]["image"]
+            self._features = json.dumps(features)
+        return self._features
+
+    @features.setter
+    def features(self, value: str) -> None:
+        self._features = value
+
+    @property
+    def features_dict(self) -> dict[str, Any]:
+        return json.loads(self.features) if self.features else {}
+
+    def user_input_form(self, to_old_structure: bool = False) -> list:
+        # get start node from graph
+        if not self.graph:
+            return []
+
+        graph_dict = self.graph_dict
+        if "nodes" not in graph_dict:
+            return []
+
+        start_node = next((node for node in graph_dict["nodes"] if node["data"]["type"] == "start"), None)
+        if not start_node:
+            return []
+
+        # get user_input_form from start node
+        variables: list[Any] = start_node.get("data", {}).get("variables", [])
+
+        if to_old_structure:
+            old_structure_variables = []
+            for variable in variables:
+                old_structure_variables.append({variable["type"]: variable})
+
+            return old_structure_variables
+
+        return variables
+
+    @property
+    def unique_hash(self) -> str:
+        """
+        Get hash of workflow.
+
+        :return: hash
+        """
+        entity = {"graph": self.graph_dict, "features": self.features_dict}
+
+        return helper.generate_text_hash(json.dumps(entity, sort_keys=True))
+
+    @property
+    def tool_published(self) -> bool:
+        from models.tools import WorkflowToolProvider
+
+        return (
+            db.session.query(WorkflowToolProvider)
+            .filter(WorkflowToolProvider.tenant_id == self.tenant_id, WorkflowToolProvider.app_id == self.app_id)
+            .count()
+            > 0
+        )
+
+    @property
+    def environment_variables(self) -> Sequence[Variable]:
+        # TODO: find some way to init `self._environment_variables` when instance created.
+        if self._environment_variables is None:
+            self._environment_variables = "{}"
+
+        tenant_id = contexts.tenant_id.get()
+
+        environment_variables_dict: dict[str, Any] = json.loads(self._environment_variables)
+        results = [
+            variable_factory.build_environment_variable_from_mapping(v) for v in environment_variables_dict.values()
+        ]
+
+        # decrypt secret variables value
+        def decrypt_func(var):
+            if isinstance(var, SecretVariable):
+                return var.model_copy(update={"value": encrypter.decrypt_token(tenant_id=tenant_id, token=var.value)})
+            else:
+                return var
+
+        results = list(map(decrypt_func, results))
+        return results
+
+    @environment_variables.setter
+    def environment_variables(self, value: Sequence[Variable]):
+        if not value:
+            self._environment_variables = "{}"
+            return
+
+        tenant_id = contexts.tenant_id.get()
+
+        value = list(value)
+        if any(var for var in value if not var.id):
+            raise ValueError("environment variable require a unique id")
+
+        # Compare inputs and origin variables,
+        # if the value is HIDDEN_VALUE, use the origin variable value (only update `name`).
+        origin_variables_dictionary = {var.id: var for var in self.environment_variables}
+        for i, variable in enumerate(value):
+            if variable.id in origin_variables_dictionary and variable.value == HIDDEN_VALUE:
+                value[i] = origin_variables_dictionary[variable.id].model_copy(update={"name": variable.name})
+
+        # encrypt secret variables value
+        def encrypt_func(var):
+            if isinstance(var, SecretVariable):
+                return var.model_copy(update={"value": encrypter.encrypt_token(tenant_id=tenant_id, token=var.value)})
+            else:
+                return var
+
+        encrypted_vars = list(map(encrypt_func, value))
+        environment_variables_json = json.dumps(
+            {var.name: var.model_dump() for var in encrypted_vars},
+            ensure_ascii=False,
+        )
+        self._environment_variables = environment_variables_json
+
+    def to_dict(self, *, include_secret: bool = False) -> Mapping[str, Any]:
+        environment_variables = list(self.environment_variables)
+        environment_variables = [
+            v if not isinstance(v, SecretVariable) or include_secret else v.model_copy(update={"value": ""})
+            for v in environment_variables
+        ]
+
+        result = {
+            "graph": self.graph_dict,
+            "features": self.features_dict,
+            "environment_variables": [var.model_dump(mode="json") for var in environment_variables],
+            "conversation_variables": [var.model_dump(mode="json") for var in self.conversation_variables],
+        }
+        return result
+
+    @property
+    def conversation_variables(self) -> Sequence[Variable]:
+        # TODO: find some way to init `self._conversation_variables` when instance created.
+        if self._conversation_variables is None:
+            self._conversation_variables = "{}"
+
+        variables_dict: dict[str, Any] = json.loads(self._conversation_variables)
+        results = [variable_factory.build_conversation_variable_from_mapping(v) for v in variables_dict.values()]
+        return results
+
+    @conversation_variables.setter
+    def conversation_variables(self, value: Sequence[Variable]) -> None:
+        self._conversation_variables = json.dumps(
+            {var.name: var.model_dump() for var in value},
+            ensure_ascii=False,
+        )
+
+
+class WorkflowRunStatus(StrEnum):
+    """
+    Workflow Run Status Enum
+    """
+
+    RUNNING = "running"
+    SUCCEEDED = "succeeded"
+    FAILED = "failed"
+    STOPPED = "stopped"
+    PARTIAL_SUCCEEDED = "partial-succeeded"
+
+
+class WorkflowRun(Base):
+    """
+    Workflow Run
+
+    Attributes:
+
+    - id (uuid) Run ID
+    - tenant_id (uuid) Workspace ID
+    - app_id (uuid) App ID
+    - sequence_number (int) Auto-increment sequence number, incremented within the App, starting from 1
+    - workflow_id (uuid) Workflow ID
+    - type (string) Workflow type
+    - triggered_from (string) Trigger source
+
+        `debugging` for canvas debugging
+
+        `app-run` for (published) app execution
+
+    - version (string) Version
+    - graph (text) Workflow canvas configuration (JSON)
+    - inputs (text) Input parameters
+    - status (string) Execution status, `running` / `succeeded` / `failed` / `stopped`
+    - outputs (text) `optional` Output content
+    - error (string) `optional` Error reason
+    - elapsed_time (float) `optional` Time consumption (s)
+    - total_tokens (int) `optional` Total tokens used
+    - total_steps (int) Total steps (redundant), default 0
+    - created_by_role (string) Creator role
+
+        - `account` Console account
+
+        - `end_user` End user
+
+    - created_by (uuid) Runner ID
+    - created_at (timestamp) Run time
+    - finished_at (timestamp) End time
+    """
+
+    __tablename__ = "workflow_runs"
+    __table_args__ = (
+        db.PrimaryKeyConstraint("id", name="workflow_run_pkey"),
+        db.Index("workflow_run_triggerd_from_idx", "tenant_id", "app_id", "triggered_from"),
+        db.Index("workflow_run_tenant_app_sequence_idx", "tenant_id", "app_id", "sequence_number"),
+    )
+
+    id: Mapped[str] = mapped_column(StringUUID, server_default=db.text("uuid_generate_v4()"))
+    tenant_id: Mapped[str] = mapped_column(StringUUID)
+    app_id: Mapped[str] = mapped_column(StringUUID)
+    sequence_number: Mapped[int] = mapped_column()
+    workflow_id: Mapped[str] = mapped_column(StringUUID)
+    type: Mapped[str] = mapped_column(db.String(255))
+    triggered_from: Mapped[str] = mapped_column(db.String(255))
+    version: Mapped[str] = mapped_column(db.String(255))
+    graph: Mapped[Optional[str]] = mapped_column(db.Text)
+    inputs: Mapped[Optional[str]] = mapped_column(db.Text)
+    status: Mapped[str] = mapped_column(db.String(255))  # running, succeeded, failed, stopped, partial-succeeded
+    outputs: Mapped[Optional[str]] = mapped_column(sa.Text, default="{}")
+    error: Mapped[Optional[str]] = mapped_column(db.Text)
+    elapsed_time = db.Column(db.Float, nullable=False, server_default=sa.text("0"))
+    total_tokens: Mapped[int] = mapped_column(sa.BigInteger, server_default=sa.text("0"))
+    total_steps = db.Column(db.Integer, server_default=db.text("0"))
+    created_by_role: Mapped[str] = mapped_column(db.String(255))  # account, end_user
+    created_by = db.Column(StringUUID, nullable=False)
+    created_at = db.Column(db.DateTime, nullable=False, server_default=func.current_timestamp())
+    finished_at = db.Column(db.DateTime)
+    exceptions_count = db.Column(db.Integer, server_default=db.text("0"))
+
+    @property
+    def created_by_account(self):
+        created_by_role = CreatedByRole(self.created_by_role)
+        return db.session.get(Account, self.created_by) if created_by_role == CreatedByRole.ACCOUNT else None
+
+    @property
+    def created_by_end_user(self):
+        from models.model import EndUser
+
+        created_by_role = CreatedByRole(self.created_by_role)
+        return db.session.get(EndUser, self.created_by) if created_by_role == CreatedByRole.END_USER else None
+
+    @property
+    def graph_dict(self):
+        return json.loads(self.graph) if self.graph else {}
+
+    @property
+    def inputs_dict(self) -> Mapping[str, Any]:
+        return json.loads(self.inputs) if self.inputs else {}
+
+    @property
+    def outputs_dict(self) -> Mapping[str, Any]:
+        return json.loads(self.outputs) if self.outputs else {}
+
+    @property
+    def message(self):
+        from models.model import Message
+
+        return (
+            db.session.query(Message).filter(Message.app_id == self.app_id, Message.workflow_run_id == self.id).first()
+        )
+
+    @property
+    def workflow(self):
+        return db.session.query(Workflow).filter(Workflow.id == self.workflow_id).first()
+
+    def to_dict(self):
+        return {
+            "id": self.id,
+            "tenant_id": self.tenant_id,
+            "app_id": self.app_id,
+            "sequence_number": self.sequence_number,
+            "workflow_id": self.workflow_id,
+            "type": self.type,
+            "triggered_from": self.triggered_from,
+            "version": self.version,
+            "graph": self.graph_dict,
+            "inputs": self.inputs_dict,
+            "status": self.status,
+            "outputs": self.outputs_dict,
+            "error": self.error,
+            "elapsed_time": self.elapsed_time,
+            "total_tokens": self.total_tokens,
+            "total_steps": self.total_steps,
+            "created_by_role": self.created_by_role,
+            "created_by": self.created_by,
+            "created_at": self.created_at,
+            "finished_at": self.finished_at,
+            "exceptions_count": self.exceptions_count,
+        }
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "WorkflowRun":
+        return cls(
+            id=data.get("id"),
+            tenant_id=data.get("tenant_id"),
+            app_id=data.get("app_id"),
+            sequence_number=data.get("sequence_number"),
+            workflow_id=data.get("workflow_id"),
+            type=data.get("type"),
+            triggered_from=data.get("triggered_from"),
+            version=data.get("version"),
+            graph=json.dumps(data.get("graph")),
+            inputs=json.dumps(data.get("inputs")),
+            status=data.get("status"),
+            outputs=json.dumps(data.get("outputs")),
+            error=data.get("error"),
+            elapsed_time=data.get("elapsed_time"),
+            total_tokens=data.get("total_tokens"),
+            total_steps=data.get("total_steps"),
+            created_by_role=data.get("created_by_role"),
+            created_by=data.get("created_by"),
+            created_at=data.get("created_at"),
+            finished_at=data.get("finished_at"),
+            exceptions_count=data.get("exceptions_count"),
+        )
+
+
+class WorkflowNodeExecutionTriggeredFrom(Enum):
+    """
+    Workflow Node Execution Triggered From Enum
+    """
+
+    SINGLE_STEP = "single-step"
+    WORKFLOW_RUN = "workflow-run"
+
+    @classmethod
+    def value_of(cls, value: str) -> "WorkflowNodeExecutionTriggeredFrom":
+        """
+        Get value of given mode.
+
+        :param value: mode value
+        :return: mode
+        """
+        for mode in cls:
+            if mode.value == value:
+                return mode
+        raise ValueError(f"invalid workflow node execution triggered from value {value}")
+
+
+class WorkflowNodeExecutionStatus(Enum):
+    """
+    Workflow Node Execution Status Enum
+    """
+
+    RUNNING = "running"
+    SUCCEEDED = "succeeded"
+    FAILED = "failed"
+    EXCEPTION = "exception"
+    RETRY = "retry"
+
+    @classmethod
+    def value_of(cls, value: str) -> "WorkflowNodeExecutionStatus":
+        """
+        Get value of given mode.
+
+        :param value: mode value
+        :return: mode
+        """
+        for mode in cls:
+            if mode.value == value:
+                return mode
+        raise ValueError(f"invalid workflow node execution status value {value}")
+
+
+class WorkflowNodeExecution(Base):
+    """
+    Workflow Node Execution
+
+    - id (uuid) Execution ID
+    - tenant_id (uuid) Workspace ID
+    - app_id (uuid) App ID
+    - workflow_id (uuid) Workflow ID
+    - triggered_from (string) Trigger source
+
+        `single-step` for single-step debugging
+
+        `workflow-run` for workflow execution (debugging / user execution)
+
+    - workflow_run_id (uuid) `optional` Workflow run ID
+
+        Null for single-step debugging.
+
+    - index (int) Execution sequence number, used for displaying Tracing Node order
+    - predecessor_node_id (string) `optional` Predecessor node ID, used for displaying execution path
+    - node_id (string) Node ID
+    - node_type (string) Node type, such as `start`
+    - title (string) Node title
+    - inputs (json) All predecessor node variable content used in the node
+    - process_data (json) Node process data
+    - outputs (json) `optional` Node output variables
+    - status (string) Execution status, `running` / `succeeded` / `failed`
+    - error (string) `optional` Error reason
+    - elapsed_time (float) `optional` Time consumption (s)
+    - execution_metadata (text) Metadata
+
+        - total_tokens (int) `optional` Total tokens used
+
+        - total_price (decimal) `optional` Total cost
+
+        - currency (string) `optional` Currency, such as USD / RMB
+
+    - created_at (timestamp) Run time
+    - created_by_role (string) Creator role
+
+        - `account` Console account
+
+        - `end_user` End user
+
+    - created_by (uuid) Runner ID
+    - finished_at (timestamp) End time
+    """
+
+    __tablename__ = "workflow_node_executions"
+    __table_args__ = (
+        db.PrimaryKeyConstraint("id", name="workflow_node_execution_pkey"),
+        db.Index(
+            "workflow_node_execution_workflow_run_idx",
+            "tenant_id",
+            "app_id",
+            "workflow_id",
+            "triggered_from",
+            "workflow_run_id",
+        ),
+        db.Index(
+            "workflow_node_execution_node_run_idx", "tenant_id", "app_id", "workflow_id", "triggered_from", "node_id"
+        ),
+        db.Index(
+            "workflow_node_execution_id_idx",
+            "tenant_id",
+            "app_id",
+            "workflow_id",
+            "triggered_from",
+            "node_execution_id",
+        ),
+    )
+
+    id: Mapped[str] = mapped_column(StringUUID, server_default=db.text("uuid_generate_v4()"))
+    tenant_id: Mapped[str] = mapped_column(StringUUID)
+    app_id: Mapped[str] = mapped_column(StringUUID)
+    workflow_id: Mapped[str] = mapped_column(StringUUID)
+    triggered_from: Mapped[str] = mapped_column(db.String(255))
+    workflow_run_id: Mapped[Optional[str]] = mapped_column(StringUUID)
+    index: Mapped[int] = mapped_column(db.Integer)
+    predecessor_node_id: Mapped[Optional[str]] = mapped_column(db.String(255))
+    node_execution_id: Mapped[Optional[str]] = mapped_column(db.String(255))
+    node_id: Mapped[str] = mapped_column(db.String(255))
+    node_type: Mapped[str] = mapped_column(db.String(255))
+    title: Mapped[str] = mapped_column(db.String(255))
+    inputs: Mapped[Optional[str]] = mapped_column(db.Text)
+    process_data: Mapped[Optional[str]] = mapped_column(db.Text)
+    outputs: Mapped[Optional[str]] = mapped_column(db.Text)
+    status: Mapped[str] = mapped_column(db.String(255))
+    error: Mapped[Optional[str]] = mapped_column(db.Text)
+    elapsed_time: Mapped[float] = mapped_column(db.Float, server_default=db.text("0"))
+    execution_metadata: Mapped[Optional[str]] = mapped_column(db.Text)
+    created_at: Mapped[datetime] = mapped_column(db.DateTime, server_default=func.current_timestamp())
+    created_by_role: Mapped[str] = mapped_column(db.String(255))
+    created_by: Mapped[str] = mapped_column(StringUUID)
+    finished_at: Mapped[Optional[datetime]] = mapped_column(db.DateTime)
+
+    @property
+    def created_by_account(self):
+        created_by_role = CreatedByRole(self.created_by_role)
+        return db.session.get(Account, self.created_by) if created_by_role == CreatedByRole.ACCOUNT else None
+
+    @property
+    def created_by_end_user(self):
+        from models.model import EndUser
+
+        created_by_role = CreatedByRole(self.created_by_role)
+        return db.session.get(EndUser, self.created_by) if created_by_role == CreatedByRole.END_USER else None
+
+    @property
+    def inputs_dict(self):
+        return json.loads(self.inputs) if self.inputs else None
+
+    @property
+    def outputs_dict(self):
+        return json.loads(self.outputs) if self.outputs else None
+
+    @property
+    def process_data_dict(self):
+        return json.loads(self.process_data) if self.process_data else None
+
+    @property
+    def execution_metadata_dict(self):
+        return json.loads(self.execution_metadata) if self.execution_metadata else None
+
+    @property
+    def extras(self):
+        from core.tools.tool_manager import ToolManager
+
+        extras = {}
+        if self.execution_metadata_dict:
+            from core.workflow.nodes import NodeType
+
+            if self.node_type == NodeType.TOOL.value and "tool_info" in self.execution_metadata_dict:
+                tool_info = self.execution_metadata_dict["tool_info"]
+                extras["icon"] = ToolManager.get_tool_icon(
+                    tenant_id=self.tenant_id,
+                    provider_type=tool_info["provider_type"],
+                    provider_id=tool_info["provider_id"],
+                )
+
+        return extras
+
+
+class WorkflowAppLogCreatedFrom(Enum):
+    """
+    Workflow App Log Created From Enum
+    """
+
+    SERVICE_API = "service-api"
+    WEB_APP = "web-app"
+    INSTALLED_APP = "installed-app"
+
+    @classmethod
+    def value_of(cls, value: str) -> "WorkflowAppLogCreatedFrom":
+        """
+        Get value of given mode.
+
+        :param value: mode value
+        :return: mode
+        """
+        for mode in cls:
+            if mode.value == value:
+                return mode
+        raise ValueError(f"invalid workflow app log created from value {value}")
+
+
+class WorkflowAppLog(Base):
+    """
+    Workflow App execution log, excluding workflow debugging records.
+
+    Attributes:
+
+    - id (uuid) run ID
+    - tenant_id (uuid) Workspace ID
+    - app_id (uuid) App ID
+    - workflow_id (uuid) Associated Workflow ID
+    - workflow_run_id (uuid) Associated Workflow Run ID
+    - created_from (string) Creation source
+
+        `service-api` App Execution OpenAPI
+
+        `web-app` WebApp
+
+        `installed-app` Installed App
+
+    - created_by_role (string) Creator role
+
+        - `account` Console account
+
+        - `end_user` End user
+
+    - created_by (uuid) Creator ID, depends on the user table according to created_by_role
+    - created_at (timestamp) Creation time
+    """
+
+    __tablename__ = "workflow_app_logs"
+    __table_args__ = (
+        db.PrimaryKeyConstraint("id", name="workflow_app_log_pkey"),
+        db.Index("workflow_app_log_app_idx", "tenant_id", "app_id", "created_at"),
+        db.Index("workflow_app_log_workflow_run_idx", "workflow_run_id"),
+    )
+
+    id: Mapped[str] = mapped_column(StringUUID, server_default=db.text("uuid_generate_v4()"))
+    tenant_id: Mapped[str] = mapped_column(StringUUID)
+    app_id: Mapped[str] = mapped_column(StringUUID)
+    workflow_id = db.Column(StringUUID, nullable=False)
+    workflow_run_id: Mapped[str] = mapped_column(StringUUID)
+    created_from = db.Column(db.String(255), nullable=False)
+    created_by_role = db.Column(db.String(255), nullable=False)
+    created_by = db.Column(StringUUID, nullable=False)
+    created_at = db.Column(db.DateTime, nullable=False, server_default=func.current_timestamp())
+
+    @property
+    def workflow_run(self):
+        return db.session.get(WorkflowRun, self.workflow_run_id)
+
+    @property
+    def created_by_account(self):
+        created_by_role = CreatedByRole(self.created_by_role)
+        return db.session.get(Account, self.created_by) if created_by_role == CreatedByRole.ACCOUNT else None
+
+    @property
+    def created_by_end_user(self):
+        from models.model import EndUser
+
+        created_by_role = CreatedByRole(self.created_by_role)
+        return db.session.get(EndUser, self.created_by) if created_by_role == CreatedByRole.END_USER else None
+
+
+class ConversationVariable(Base):
+    __tablename__ = "workflow_conversation_variables"
+    __table_args__ = (
+        PrimaryKeyConstraint("id", "conversation_id", name="workflow_conversation_variables_pkey"),
+        Index("workflow__conversation_variables_app_id_idx", "app_id"),
+        Index("workflow__conversation_variables_created_at_idx", "created_at"),
+    )
+
+    id: Mapped[str] = mapped_column(StringUUID, primary_key=True)
+    conversation_id: Mapped[str] = mapped_column(StringUUID, nullable=False, primary_key=True)
+    app_id: Mapped[str] = mapped_column(StringUUID, nullable=False)
+    data = mapped_column(db.Text, nullable=False)
+    created_at = mapped_column(db.DateTime, nullable=False, server_default=func.current_timestamp())
+    updated_at = mapped_column(
+        db.DateTime, nullable=False, server_default=func.current_timestamp(), onupdate=func.current_timestamp()
+    )
+
+    def __init__(self, *, id: str, app_id: str, conversation_id: str, data: str) -> None:
+        self.id = id
+        self.app_id = app_id
+        self.conversation_id = conversation_id
+        self.data = data
+
+    @classmethod
+    def from_variable(cls, *, app_id: str, conversation_id: str, variable: Variable) -> "ConversationVariable":
+        obj = cls(
+            id=variable.id,
+            app_id=app_id,
+            conversation_id=conversation_id,
+            data=variable.model_dump_json(),
+        )
+        return obj
+
+    def to_variable(self) -> Variable:
+        mapping = json.loads(self.data)
+        return variable_factory.build_conversation_variable_from_mapping(mapping)