Initial commit

dify_1.9.0/api/models/__init__.py

@@ -0,0 +1,184 @@
+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 .enums import CreatorUserRole, UserFrom, WorkflowRunTriggeredFrom
+from .model import (
+    ApiRequest,
+    ApiToken,
+    App,
+    AppAnnotationHitHistory,
+    AppAnnotationSetting,
+    AppMCPServer,
+    AppMode,
+    AppModelConfig,
+    Conversation,
+    DatasetRetrieverResource,
+    DifySetup,
+    EndUser,
+    IconType,
+    InstalledApp,
+    Message,
+    MessageAgentThought,
+    MessageAnnotation,
+    MessageChain,
+    MessageFeedback,
+    MessageFile,
+    OperationLog,
+    RecommendedApp,
+    Site,
+    Tag,
+    TagBinding,
+    TraceAppConfig,
+    UploadFile,
+)
+from .oauth import DatasourceOauthParamConfig, DatasourceProvider
+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,
+    WorkflowNodeExecutionModel,
+    WorkflowNodeExecutionOffload,
+    WorkflowNodeExecutionTriggeredFrom,
+    WorkflowRun,
+    WorkflowType,
+)
+
+__all__ = [
+    "APIBasedExtension",
+    "APIBasedExtensionPoint",
+    "Account",
+    "AccountIntegrate",
+    "AccountStatus",
+    "ApiRequest",
+    "ApiToken",
+    "ApiToolProvider",
+    "App",
+    "AppAnnotationHitHistory",
+    "AppAnnotationSetting",
+    "AppDatasetJoin",
+    "AppMCPServer",  # Added
+    "AppMode",
+    "AppModelConfig",
+    "BuiltinToolProvider",
+    "CeleryTask",
+    "CeleryTaskSet",
+    "Conversation",
+    "ConversationVariable",
+    "CreatorUserRole",
+    "DataSourceApiKeyAuthBinding",
+    "DataSourceOauthBinding",
+    "Dataset",
+    "DatasetCollectionBinding",
+    "DatasetKeywordTable",
+    "DatasetPermission",
+    "DatasetPermissionEnum",
+    "DatasetProcessRule",
+    "DatasetQuery",
+    "DatasetRetrieverResource",
+    "DatasourceOauthParamConfig",
+    "DatasourceProvider",
+    "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",
+    "WorkflowNodeExecutionModel",
+    "WorkflowNodeExecutionOffload",
+    "WorkflowNodeExecutionTriggeredFrom",
+    "WorkflowRun",
+    "WorkflowRunTriggeredFrom",
+    "WorkflowToolProvider",
+    "WorkflowType",
+]

dify_1.9.0/api/models/_workflow_exc.py

@@ -0,0 +1,20 @@
+"""All these exceptions are not meant to be caught by callers."""
+
+
+class WorkflowDataError(Exception):
+    """Base class for all workflow data related exceptions.
+
+    This should be used to indicate issues with workflow data integrity, such as
+    no `graph` configuration, missing `nodes` field in `graph` configuration, or
+    similar issues.
+    """
+
+    pass
+
+
+class NodeNotFoundError(WorkflowDataError):
+    """Raised when a node with the specified ID is not found in the workflow."""
+
+    def __init__(self, node_id: str):
+        super().__init__(f"Node with ID '{node_id}' not found in the workflow.")
+        self.node_id = node_id

dify_1.9.0/api/models/account.py

@@ -0,0 +1,363 @@
+import enum
+import json
+from datetime import datetime
+from typing import Any, Optional
+
+import sqlalchemy as sa
+from flask_login import UserMixin  # type: ignore[import-untyped]
+from sqlalchemy import DateTime, String, func, select
+from sqlalchemy.orm import Mapped, Session, mapped_column, reconstructor
+from typing_extensions import deprecated
+
+from models.base import Base
+
+from .engine import db
+from .types import StringUUID
+
+
+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: Optional["TenantAccountRole"]) -> bool:
+        if not role:
+            return False
+        return role in {TenantAccountRole.OWNER, TenantAccountRole.ADMIN}
+
+    @staticmethod
+    def is_admin_role(role: Optional["TenantAccountRole"]) -> bool:
+        if not role:
+            return False
+        return role == TenantAccountRole.ADMIN
+
+    @staticmethod
+    def is_non_owner_role(role: Optional["TenantAccountRole"]) -> bool:
+        if not role:
+            return False
+        return role in {
+            TenantAccountRole.ADMIN,
+            TenantAccountRole.EDITOR,
+            TenantAccountRole.NORMAL,
+            TenantAccountRole.DATASET_OPERATOR,
+        }
+
+    @staticmethod
+    def is_editing_role(role: Optional["TenantAccountRole"]) -> bool:
+        if not role:
+            return False
+        return role in {TenantAccountRole.OWNER, TenantAccountRole.ADMIN, TenantAccountRole.EDITOR}
+
+    @staticmethod
+    def is_dataset_edit_role(role: Optional["TenantAccountRole"]) -> bool:
+        if not role:
+            return False
+        return role in {
+            TenantAccountRole.OWNER,
+            TenantAccountRole.ADMIN,
+            TenantAccountRole.EDITOR,
+            TenantAccountRole.DATASET_OPERATOR,
+        }
+
+
+class AccountStatus(enum.StrEnum):
+    PENDING = "pending"
+    UNINITIALIZED = "uninitialized"
+    ACTIVE = "active"
+    BANNED = "banned"
+    CLOSED = "closed"
+
+
+class Account(UserMixin, Base):
+    __tablename__ = "accounts"
+    __table_args__ = (sa.PrimaryKeyConstraint("id", name="account_pkey"), sa.Index("account_email_idx", "email"))
+
+    id: Mapped[str] = mapped_column(StringUUID, server_default=sa.text("uuid_generate_v4()"))
+    name: Mapped[str] = mapped_column(String(255))
+    email: Mapped[str] = mapped_column(String(255))
+    password: Mapped[str | None] = mapped_column(String(255))
+    password_salt: Mapped[str | None] = mapped_column(String(255))
+    avatar: Mapped[str | None] = mapped_column(String(255), nullable=True)
+    interface_language: Mapped[str | None] = mapped_column(String(255))
+    interface_theme: Mapped[str | None] = mapped_column(String(255), nullable=True)
+    timezone: Mapped[str | None] = mapped_column(String(255))
+    last_login_at: Mapped[datetime | None] = mapped_column(DateTime, nullable=True)
+    last_login_ip: Mapped[str | None] = mapped_column(String(255), nullable=True)
+    last_active_at: Mapped[datetime] = mapped_column(DateTime, server_default=func.current_timestamp(), nullable=False)
+    status: Mapped[str] = mapped_column(String(16), server_default=sa.text("'active'::character varying"))
+    initialized_at: Mapped[datetime | None] = mapped_column(DateTime, nullable=True)
+    created_at: Mapped[datetime] = mapped_column(DateTime, server_default=func.current_timestamp(), nullable=False)
+    updated_at: Mapped[datetime] = mapped_column(DateTime, server_default=func.current_timestamp(), nullable=False)
+
+    @reconstructor
+    def init_on_load(self):
+        self.role: TenantAccountRole | None = None
+        self._current_tenant: Tenant | None = None
+
+    @property
+    def is_password_set(self):
+        return self.password is not None
+
+    @property
+    def current_tenant(self):
+        return self._current_tenant
+
+    @current_tenant.setter
+    def current_tenant(self, tenant: "Tenant"):
+        with Session(db.engine, expire_on_commit=False) as session:
+            tenant_join_query = select(TenantAccountJoin).where(
+                TenantAccountJoin.tenant_id == tenant.id, TenantAccountJoin.account_id == self.id
+            )
+            tenant_join = session.scalar(tenant_join_query)
+            tenant_query = select(Tenant).where(Tenant.id == tenant.id)
+            # TODO: A workaround to reload the tenant with `expire_on_commit=False`, allowing
+            # access to it after the session has been closed.
+            # This prevents `DetachedInstanceError` when accessing the tenant outside
+            # the session's lifecycle.
+            # (The `tenant` argument is typically loaded by `db.session` without the
+            # `expire_on_commit=False` flag, meaning its lifetime is tied to the web
+            # request's lifecycle.)
+            tenant_reloaded = session.scalars(tenant_query).one()
+
+        if tenant_join:
+            self.role = TenantAccountRole(tenant_join.role)
+            self._current_tenant = tenant_reloaded
+            return
+        self._current_tenant = None
+
+    @property
+    def current_tenant_id(self) -> str | None:
+        return self._current_tenant.id if self._current_tenant else None
+
+    def set_tenant_id(self, tenant_id: str):
+        query = (
+            select(Tenant, TenantAccountJoin)
+            .where(Tenant.id == tenant_id)
+            .where(TenantAccountJoin.tenant_id == Tenant.id)
+            .where(TenantAccountJoin.account_id == self.id)
+        )
+        with Session(db.engine, expire_on_commit=False) as session:
+            tenant_account_join = session.execute(query).first()
+            if not tenant_account_join:
+                return
+            tenant, join = tenant_account_join
+            self.role = TenantAccountRole(join.role)
+            self._current_tenant = tenant
+
+    @property
+    def current_role(self):
+        return self.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)
+            .where(AccountIntegrate.provider == provider, AccountIntegrate.open_id == open_id)
+            .one_or_none()
+        )
+        if account_integrate:
+            return db.session.query(Account).where(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.role)
+
+    @property
+    def is_admin(self):
+        return TenantAccountRole.is_admin_role(self.role)
+
+    @property
+    @deprecated("Use has_edit_permission instead.")
+    def is_editor(self):
+        """Determines if the account has edit permissions in their current tenant (workspace).
+
+        This property checks if the current role has editing privileges, which includes:
+        - `OWNER`
+        - `ADMIN`
+        - `EDITOR`
+
+        Note: This checks for any role with editing permission, not just the 'EDITOR' role specifically.
+        """
+        return self.has_edit_permission
+
+    @property
+    def has_edit_permission(self):
+        """Determines if the account has editing permissions in their current tenant (workspace).
+
+        This property checks if the current role has editing privileges, which includes:
+        - `OWNER`
+        - `ADMIN`
+        - `EDITOR`
+        """
+        return TenantAccountRole.is_editing_role(self.role)
+
+    @property
+    def is_dataset_editor(self):
+        return TenantAccountRole.is_dataset_edit_role(self.role)
+
+    @property
+    def is_dataset_operator(self):
+        return self.role == TenantAccountRole.DATASET_OPERATOR
+
+
+class TenantStatus(enum.StrEnum):
+    NORMAL = "normal"
+    ARCHIVE = "archive"
+
+
+class Tenant(Base):
+    __tablename__ = "tenants"
+    __table_args__ = (sa.PrimaryKeyConstraint("id", name="tenant_pkey"),)
+
+    id: Mapped[str] = mapped_column(StringUUID, server_default=sa.text("uuid_generate_v4()"))
+    name: Mapped[str] = mapped_column(String(255))
+    encrypt_public_key: Mapped[str | None] = mapped_column(sa.Text)
+    plan: Mapped[str] = mapped_column(String(255), server_default=sa.text("'basic'::character varying"))
+    status: Mapped[str] = mapped_column(String(255), server_default=sa.text("'normal'::character varying"))
+    custom_config: Mapped[str | None] = mapped_column(sa.Text)
+    created_at: Mapped[datetime] = mapped_column(DateTime, server_default=func.current_timestamp(), nullable=False)
+    updated_at: Mapped[datetime] = mapped_column(DateTime, server_default=func.current_timestamp())
+
+    def get_accounts(self) -> list[Account]:
+        return list(
+            db.session.scalars(
+                select(Account).where(
+                    Account.id == TenantAccountJoin.account_id, TenantAccountJoin.tenant_id == self.id
+                )
+            ).all()
+        )
+
+    @property
+    def custom_config_dict(self) -> dict[str, Any]:
+        return json.loads(self.custom_config) if self.custom_config else {}
+
+    @custom_config_dict.setter
+    def custom_config_dict(self, value: dict[str, Any]) -> None:
+        self.custom_config = json.dumps(value)
+
+
+class TenantAccountJoin(Base):
+    __tablename__ = "tenant_account_joins"
+    __table_args__ = (
+        sa.PrimaryKeyConstraint("id", name="tenant_account_join_pkey"),
+        sa.Index("tenant_account_join_account_id_idx", "account_id"),
+        sa.Index("tenant_account_join_tenant_id_idx", "tenant_id"),
+        sa.UniqueConstraint("tenant_id", "account_id", name="unique_tenant_account_join"),
+    )
+
+    id: Mapped[str] = mapped_column(StringUUID, server_default=sa.text("uuid_generate_v4()"))
+    tenant_id: Mapped[str] = mapped_column(StringUUID)
+    account_id: Mapped[str] = mapped_column(StringUUID)
+    current: Mapped[bool] = mapped_column(sa.Boolean, server_default=sa.text("false"))
+    role: Mapped[str] = mapped_column(String(16), server_default="normal")
+    invited_by: Mapped[str | None] = mapped_column(StringUUID)
+    created_at: Mapped[datetime] = mapped_column(DateTime, server_default=func.current_timestamp())
+    updated_at: Mapped[datetime] = mapped_column(DateTime, server_default=func.current_timestamp())
+
+
+class AccountIntegrate(Base):
+    __tablename__ = "account_integrates"
+    __table_args__ = (
+        sa.PrimaryKeyConstraint("id", name="account_integrate_pkey"),
+        sa.UniqueConstraint("account_id", "provider", name="unique_account_provider"),
+        sa.UniqueConstraint("provider", "open_id", name="unique_provider_open_id"),
+    )
+
+    id: Mapped[str] = mapped_column(StringUUID, server_default=sa.text("uuid_generate_v4()"))
+    account_id: Mapped[str] = mapped_column(StringUUID)
+    provider: Mapped[str] = mapped_column(String(16))
+    open_id: Mapped[str] = mapped_column(String(255))
+    encrypted_token: Mapped[str] = mapped_column(String(255))
+    created_at: Mapped[datetime] = mapped_column(DateTime, server_default=func.current_timestamp())
+    updated_at: Mapped[datetime] = mapped_column(DateTime, server_default=func.current_timestamp())
+
+
+class InvitationCode(Base):
+    __tablename__ = "invitation_codes"
+    __table_args__ = (
+        sa.PrimaryKeyConstraint("id", name="invitation_code_pkey"),
+        sa.Index("invitation_codes_batch_idx", "batch"),
+        sa.Index("invitation_codes_code_idx", "code", "status"),
+    )
+
+    id: Mapped[int] = mapped_column(sa.Integer)
+    batch: Mapped[str] = mapped_column(String(255))
+    code: Mapped[str] = mapped_column(String(32))
+    status: Mapped[str] = mapped_column(String(16), server_default=sa.text("'unused'::character varying"))
+    used_at: Mapped[datetime | None] = mapped_column(DateTime)
+    used_by_tenant_id: Mapped[str | None] = mapped_column(StringUUID)
+    used_by_account_id: Mapped[str | None] = mapped_column(StringUUID)
+    deprecated_at: Mapped[datetime | None] = mapped_column(DateTime, nullable=True)
+    created_at: Mapped[datetime] = mapped_column(DateTime, server_default=sa.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__ = (
+        sa.PrimaryKeyConstraint("id", name="account_plugin_permission_pkey"),
+        sa.UniqueConstraint("tenant_id", name="unique_tenant_plugin"),
+    )
+
+    id: Mapped[str] = mapped_column(StringUUID, server_default=sa.text("uuid_generate_v4()"))
+    tenant_id: Mapped[str] = mapped_column(StringUUID, nullable=False)
+    install_permission: Mapped[InstallPermission] = mapped_column(String(16), nullable=False, server_default="everyone")
+    debug_permission: Mapped[DebugPermission] = mapped_column(String(16), nullable=False, server_default="noone")
+
+
+class TenantPluginAutoUpgradeStrategy(Base):
+    class StrategySetting(enum.StrEnum):
+        DISABLED = "disabled"
+        FIX_ONLY = "fix_only"
+        LATEST = "latest"
+
+    class UpgradeMode(enum.StrEnum):
+        ALL = "all"
+        PARTIAL = "partial"
+        EXCLUDE = "exclude"
+
+    __tablename__ = "tenant_plugin_auto_upgrade_strategies"
+    __table_args__ = (
+        sa.PrimaryKeyConstraint("id", name="tenant_plugin_auto_upgrade_strategy_pkey"),
+        sa.UniqueConstraint("tenant_id", name="unique_tenant_plugin_auto_upgrade_strategy"),
+    )
+
+    id: Mapped[str] = mapped_column(StringUUID, server_default=sa.text("uuid_generate_v4()"))
+    tenant_id: Mapped[str] = mapped_column(StringUUID, nullable=False)
+    strategy_setting: Mapped[StrategySetting] = mapped_column(String(16), nullable=False, server_default="fix_only")
+    upgrade_time_of_day: Mapped[int] = mapped_column(sa.Integer, nullable=False, default=0)  # seconds of the day
+    upgrade_mode: Mapped[UpgradeMode] = mapped_column(String(16), nullable=False, server_default="exclude")
+    exclude_plugins: Mapped[list[str]] = mapped_column(sa.ARRAY(String(255)), nullable=False)  # plugin_id (author/name)
+    include_plugins: Mapped[list[str]] = mapped_column(sa.ARRAY(String(255)), nullable=False)  # plugin_id (author/name)
+    created_at: Mapped[datetime] = mapped_column(DateTime, nullable=False, server_default=func.current_timestamp())
+    updated_at: Mapped[datetime] = mapped_column(DateTime, nullable=False, server_default=func.current_timestamp())

dify_1.9.0/api/models/api_based_extension.py

@@ -0,0 +1,31 @@
+import enum
+from datetime import datetime
+
+import sqlalchemy as sa
+from sqlalchemy import DateTime, String, Text, func
+from sqlalchemy.orm import Mapped, mapped_column
+
+from .base import Base
+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(Base):
+    __tablename__ = "api_based_extensions"
+    __table_args__ = (
+        sa.PrimaryKeyConstraint("id", name="api_based_extension_pkey"),
+        sa.Index("api_based_extension_tenant_idx", "tenant_id"),
+    )
+
+    id = mapped_column(StringUUID, server_default=sa.text("uuid_generate_v4()"))
+    tenant_id = mapped_column(StringUUID, nullable=False)
+    name: Mapped[str] = mapped_column(String(255), nullable=False)
+    api_endpoint: Mapped[str] = mapped_column(String(255), nullable=False)
+    api_key = mapped_column(Text, nullable=False)
+    created_at: Mapped[datetime] = mapped_column(DateTime, nullable=False, server_default=func.current_timestamp())

dify_1.9.0/api/models/base.py

@@ -0,0 +1,15 @@
+from sqlalchemy.orm import DeclarativeBase, MappedAsDataclass
+
+from models.engine import metadata
+
+
+class Base(DeclarativeBase):
+    metadata = metadata
+
+
+class TypeBase(MappedAsDataclass, DeclarativeBase):
+    """
+    This is for adding type, after all finished, rename to Base.
+    """
+
+    metadata = metadata

dify_1.9.0/api/models/engine.py

@@ -0,0 +1,25 @@
+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)
+
+# ****** IMPORTANT NOTICE ******
+#
+# NOTE(QuantumGhost): Avoid directly importing and using `db` in modules outside of the
+# `controllers` package.
+#
+# Instead, import `db` within the `controllers` package and pass it as an argument to
+# functions or class constructors.
+#
+# Directly importing `db` in other modules can make the code more difficult to read, test, and maintain.
+#
+# Whenever possible, avoid this pattern in new code.
+db = SQLAlchemy(metadata=metadata)

dify_1.9.0/api/models/enums.py

@@ -0,0 +1,40 @@
+from enum import StrEnum
+
+
+class CreatorUserRole(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"
+    RAG_PIPELINE_RUN = "rag-pipeline-run"
+    RAG_PIPELINE_DEBUGGING = "rag-pipeline-debugging"
+
+
+class DraftVariableType(StrEnum):
+    # node means that the correspond variable
+    NODE = "node"
+    SYS = "sys"
+    CONVERSATION = "conversation"
+
+
+class MessageStatus(StrEnum):
+    """
+    Message Status Enum
+    """
+
+    NORMAL = "normal"
+    ERROR = "error"
+
+
+class ExecutionOffLoadType(StrEnum):
+    INPUTS = "inputs"
+    PROCESS_DATA = "process_data"
+    OUTPUTS = "outputs"

dify_1.9.0/api/models/oauth.py

@@ -0,0 +1,61 @@
+from datetime import datetime
+
+from sqlalchemy.dialects.postgresql import JSONB
+from sqlalchemy.orm import Mapped
+
+from .base import Base
+from .engine import db
+from .types import StringUUID
+
+
+class DatasourceOauthParamConfig(Base):  # type: ignore[name-defined]
+    __tablename__ = "datasource_oauth_params"
+    __table_args__ = (
+        db.PrimaryKeyConstraint("id", name="datasource_oauth_config_pkey"),
+        db.UniqueConstraint("plugin_id", "provider", name="datasource_oauth_config_datasource_id_provider_idx"),
+    )
+
+    id = db.Column(StringUUID, server_default=db.text("uuidv7()"))
+    plugin_id: Mapped[str] = db.Column(db.String(255), nullable=False)
+    provider: Mapped[str] = db.Column(db.String(255), nullable=False)
+    system_credentials: Mapped[dict] = db.Column(JSONB, nullable=False)
+
+
+class DatasourceProvider(Base):
+    __tablename__ = "datasource_providers"
+    __table_args__ = (
+        db.PrimaryKeyConstraint("id", name="datasource_provider_pkey"),
+        db.UniqueConstraint("tenant_id", "plugin_id", "provider", "name", name="datasource_provider_unique_name"),
+        db.Index("datasource_provider_auth_type_provider_idx", "tenant_id", "plugin_id", "provider"),
+    )
+    id = db.Column(StringUUID, server_default=db.text("uuidv7()"))
+    tenant_id = db.Column(StringUUID, nullable=False)
+    name: Mapped[str] = db.Column(db.String(255), nullable=False)
+    provider: Mapped[str] = db.Column(db.String(255), nullable=False)
+    plugin_id: Mapped[str] = db.Column(db.String(255), nullable=False)
+    auth_type: Mapped[str] = db.Column(db.String(255), nullable=False)
+    encrypted_credentials: Mapped[dict] = db.Column(JSONB, nullable=False)
+    avatar_url: Mapped[str] = db.Column(db.Text, nullable=True, default="default")
+    is_default: Mapped[bool] = db.Column(db.Boolean, nullable=False, server_default=db.text("false"))
+    expires_at: Mapped[int] = db.Column(db.Integer, nullable=False, server_default="-1")
+
+    created_at: Mapped[datetime] = db.Column(db.DateTime, nullable=False, default=datetime.now)
+    updated_at: Mapped[datetime] = db.Column(db.DateTime, nullable=False, default=datetime.now)
+
+
+class DatasourceOauthTenantParamConfig(Base):
+    __tablename__ = "datasource_oauth_tenant_params"
+    __table_args__ = (
+        db.PrimaryKeyConstraint("id", name="datasource_oauth_tenant_config_pkey"),
+        db.UniqueConstraint("tenant_id", "plugin_id", "provider", name="datasource_oauth_tenant_config_unique"),
+    )
+
+    id = db.Column(StringUUID, server_default=db.text("uuidv7()"))
+    tenant_id = db.Column(StringUUID, nullable=False)
+    provider: Mapped[str] = db.Column(db.String(255), nullable=False)
+    plugin_id: Mapped[str] = db.Column(db.String(255), nullable=False)
+    client_params: Mapped[dict] = db.Column(JSONB, nullable=False, default={})
+    enabled: Mapped[bool] = db.Column(db.Boolean, nullable=False, default=False)
+
+    created_at: Mapped[datetime] = db.Column(db.DateTime, nullable=False, default=datetime.now)
+    updated_at: Mapped[datetime] = db.Column(db.DateTime, nullable=False, default=datetime.now)

dify_1.9.0/api/models/provider.py

@@ -0,0 +1,310 @@
+from datetime import datetime
+from enum import StrEnum, auto
+from functools import cached_property
+
+import sqlalchemy as sa
+from sqlalchemy import DateTime, String, func, text
+from sqlalchemy.orm import Mapped, mapped_column
+
+from .base import Base
+from .engine import db
+from .types import StringUUID
+
+
+class ProviderType(StrEnum):
+    CUSTOM = auto()
+    SYSTEM = auto()
+
+    @staticmethod
+    def value_of(value: str) -> "ProviderType":
+        for member in ProviderType:
+            if member.value == value:
+                return member
+        raise ValueError(f"No matching enum found for value '{value}'")
+
+
+class ProviderQuotaType(StrEnum):
+    PAID = auto()
+    """hosted paid quota"""
+
+    FREE = auto()
+    """third-party free quota"""
+
+    TRIAL = auto()
+    """hosted trial quota"""
+
+    @staticmethod
+    def value_of(value: str) -> "ProviderQuotaType":
+        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__ = (
+        sa.PrimaryKeyConstraint("id", name="provider_pkey"),
+        sa.Index("provider_tenant_id_provider_idx", "tenant_id", "provider_name"),
+        sa.UniqueConstraint(
+            "tenant_id", "provider_name", "provider_type", "quota_type", name="unique_provider_name_type_quota"
+        ),
+    )
+
+    id: Mapped[str] = mapped_column(StringUUID, server_default=text("uuid_generate_v4()"))
+    tenant_id: Mapped[str] = mapped_column(StringUUID, nullable=False)
+    provider_name: Mapped[str] = mapped_column(String(255), nullable=False)
+    provider_type: Mapped[str] = mapped_column(
+        String(40), nullable=False, server_default=text("'custom'::character varying")
+    )
+    is_valid: Mapped[bool] = mapped_column(sa.Boolean, nullable=False, server_default=text("false"))
+    last_used: Mapped[datetime | None] = mapped_column(DateTime, nullable=True)
+    credential_id: Mapped[str | None] = mapped_column(StringUUID, nullable=True)
+
+    quota_type: Mapped[str | None] = mapped_column(
+        String(40), nullable=True, server_default=text("''::character varying")
+    )
+    quota_limit: Mapped[int | None] = mapped_column(sa.BigInteger, nullable=True)
+    quota_used: Mapped[int | None] = mapped_column(sa.BigInteger, default=0)
+
+    created_at: Mapped[datetime] = mapped_column(DateTime, nullable=False, server_default=func.current_timestamp())
+    updated_at: Mapped[datetime] = mapped_column(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}')>"
+        )
+
+    @cached_property
+    def credential(self):
+        if self.credential_id:
+            return db.session.query(ProviderCredential).where(ProviderCredential.id == self.credential_id).first()
+
+    @property
+    def credential_name(self):
+        credential = self.credential
+        return credential.credential_name if credential else None
+
+    @property
+    def encrypted_config(self):
+        credential = self.credential
+        return credential.encrypted_config if credential else None
+
+    @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__ = (
+        sa.PrimaryKeyConstraint("id", name="provider_model_pkey"),
+        sa.Index("provider_model_tenant_id_provider_idx", "tenant_id", "provider_name"),
+        sa.UniqueConstraint(
+            "tenant_id", "provider_name", "model_name", "model_type", name="unique_provider_model_name"
+        ),
+    )
+
+    id: Mapped[str] = mapped_column(StringUUID, server_default=text("uuid_generate_v4()"))
+    tenant_id: Mapped[str] = mapped_column(StringUUID, nullable=False)
+    provider_name: Mapped[str] = mapped_column(String(255), nullable=False)
+    model_name: Mapped[str] = mapped_column(String(255), nullable=False)
+    model_type: Mapped[str] = mapped_column(String(40), nullable=False)
+    credential_id: Mapped[str | None] = mapped_column(StringUUID, nullable=True)
+    is_valid: Mapped[bool] = mapped_column(sa.Boolean, nullable=False, server_default=text("false"))
+    created_at: Mapped[datetime] = mapped_column(DateTime, nullable=False, server_default=func.current_timestamp())
+    updated_at: Mapped[datetime] = mapped_column(DateTime, nullable=False, server_default=func.current_timestamp())
+
+    @cached_property
+    def credential(self):
+        if self.credential_id:
+            return (
+                db.session.query(ProviderModelCredential)
+                .where(ProviderModelCredential.id == self.credential_id)
+                .first()
+            )
+
+    @property
+    def credential_name(self):
+        credential = self.credential
+        return credential.credential_name if credential else None
+
+    @property
+    def encrypted_config(self):
+        credential = self.credential
+        return credential.encrypted_config if credential else None
+
+
+class TenantDefaultModel(Base):
+    __tablename__ = "tenant_default_models"
+    __table_args__ = (
+        sa.PrimaryKeyConstraint("id", name="tenant_default_model_pkey"),
+        sa.Index("tenant_default_model_tenant_id_provider_type_idx", "tenant_id", "provider_name", "model_type"),
+    )
+
+    id: Mapped[str] = mapped_column(StringUUID, server_default=text("uuid_generate_v4()"))
+    tenant_id: Mapped[str] = mapped_column(StringUUID, nullable=False)
+    provider_name: Mapped[str] = mapped_column(String(255), nullable=False)
+    model_name: Mapped[str] = mapped_column(String(255), nullable=False)
+    model_type: Mapped[str] = mapped_column(String(40), nullable=False)
+    created_at: Mapped[datetime] = mapped_column(DateTime, nullable=False, server_default=func.current_timestamp())
+    updated_at: Mapped[datetime] = mapped_column(DateTime, nullable=False, server_default=func.current_timestamp())
+
+
+class TenantPreferredModelProvider(Base):
+    __tablename__ = "tenant_preferred_model_providers"
+    __table_args__ = (
+        sa.PrimaryKeyConstraint("id", name="tenant_preferred_model_provider_pkey"),
+        sa.Index("tenant_preferred_model_provider_tenant_provider_idx", "tenant_id", "provider_name"),
+    )
+
+    id: Mapped[str] = mapped_column(StringUUID, server_default=text("uuid_generate_v4()"))
+    tenant_id: Mapped[str] = mapped_column(StringUUID, nullable=False)
+    provider_name: Mapped[str] = mapped_column(String(255), nullable=False)
+    preferred_provider_type: Mapped[str] = mapped_column(String(40), nullable=False)
+    created_at: Mapped[datetime] = mapped_column(DateTime, nullable=False, server_default=func.current_timestamp())
+    updated_at: Mapped[datetime] = mapped_column(DateTime, nullable=False, server_default=func.current_timestamp())
+
+
+class ProviderOrder(Base):
+    __tablename__ = "provider_orders"
+    __table_args__ = (
+        sa.PrimaryKeyConstraint("id", name="provider_order_pkey"),
+        sa.Index("provider_order_tenant_provider_idx", "tenant_id", "provider_name"),
+    )
+
+    id: Mapped[str] = mapped_column(StringUUID, server_default=text("uuid_generate_v4()"))
+    tenant_id: Mapped[str] = mapped_column(StringUUID, nullable=False)
+    provider_name: Mapped[str] = mapped_column(String(255), nullable=False)
+    account_id: Mapped[str] = mapped_column(StringUUID, nullable=False)
+    payment_product_id: Mapped[str] = mapped_column(String(191), nullable=False)
+    payment_id: Mapped[str | None] = mapped_column(String(191))
+    transaction_id: Mapped[str | None] = mapped_column(String(191))
+    quantity: Mapped[int] = mapped_column(sa.Integer, nullable=False, server_default=text("1"))
+    currency: Mapped[str | None] = mapped_column(String(40))
+    total_amount: Mapped[int | None] = mapped_column(sa.Integer)
+    payment_status: Mapped[str] = mapped_column(
+        String(40), nullable=False, server_default=text("'wait_pay'::character varying")
+    )
+    paid_at: Mapped[datetime | None] = mapped_column(DateTime)
+    pay_failed_at: Mapped[datetime | None] = mapped_column(DateTime)
+    refunded_at: Mapped[datetime | None] = mapped_column(DateTime)
+    created_at: Mapped[datetime] = mapped_column(DateTime, nullable=False, server_default=func.current_timestamp())
+    updated_at: Mapped[datetime] = mapped_column(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__ = (
+        sa.PrimaryKeyConstraint("id", name="provider_model_setting_pkey"),
+        sa.Index("provider_model_setting_tenant_provider_model_idx", "tenant_id", "provider_name", "model_type"),
+    )
+
+    id: Mapped[str] = mapped_column(StringUUID, server_default=text("uuid_generate_v4()"))
+    tenant_id: Mapped[str] = mapped_column(StringUUID, nullable=False)
+    provider_name: Mapped[str] = mapped_column(String(255), nullable=False)
+    model_name: Mapped[str] = mapped_column(String(255), nullable=False)
+    model_type: Mapped[str] = mapped_column(String(40), nullable=False)
+    enabled: Mapped[bool] = mapped_column(sa.Boolean, nullable=False, server_default=text("true"))
+    load_balancing_enabled: Mapped[bool] = mapped_column(sa.Boolean, nullable=False, server_default=text("false"))
+    created_at: Mapped[datetime] = mapped_column(DateTime, nullable=False, server_default=func.current_timestamp())
+    updated_at: Mapped[datetime] = mapped_column(DateTime, nullable=False, server_default=func.current_timestamp())
+
+
+class LoadBalancingModelConfig(Base):
+    """
+    Configurations for load balancing models.
+    """
+
+    __tablename__ = "load_balancing_model_configs"
+    __table_args__ = (
+        sa.PrimaryKeyConstraint("id", name="load_balancing_model_config_pkey"),
+        sa.Index("load_balancing_model_config_tenant_provider_model_idx", "tenant_id", "provider_name", "model_type"),
+    )
+
+    id: Mapped[str] = mapped_column(StringUUID, server_default=text("uuid_generate_v4()"))
+    tenant_id: Mapped[str] = mapped_column(StringUUID, nullable=False)
+    provider_name: Mapped[str] = mapped_column(String(255), nullable=False)
+    model_name: Mapped[str] = mapped_column(String(255), nullable=False)
+    model_type: Mapped[str] = mapped_column(String(40), nullable=False)
+    name: Mapped[str] = mapped_column(String(255), nullable=False)
+    encrypted_config: Mapped[str | None] = mapped_column(sa.Text, nullable=True)
+    credential_id: Mapped[str | None] = mapped_column(StringUUID, nullable=True)
+    credential_source_type: Mapped[str | None] = mapped_column(String(40), nullable=True)
+    enabled: Mapped[bool] = mapped_column(sa.Boolean, nullable=False, server_default=text("true"))
+    created_at: Mapped[datetime] = mapped_column(DateTime, nullable=False, server_default=func.current_timestamp())
+    updated_at: Mapped[datetime] = mapped_column(DateTime, nullable=False, server_default=func.current_timestamp())
+
+
+class ProviderCredential(Base):
+    """
+    Provider credential - stores multiple named credentials for each provider
+    """
+
+    __tablename__ = "provider_credentials"
+    __table_args__ = (
+        sa.PrimaryKeyConstraint("id", name="provider_credential_pkey"),
+        sa.Index("provider_credential_tenant_provider_idx", "tenant_id", "provider_name"),
+    )
+
+    id: Mapped[str] = mapped_column(StringUUID, server_default=text("uuidv7()"))
+    tenant_id: Mapped[str] = mapped_column(StringUUID, nullable=False)
+    provider_name: Mapped[str] = mapped_column(String(255), nullable=False)
+    credential_name: Mapped[str] = mapped_column(String(255), nullable=False)
+    encrypted_config: Mapped[str] = mapped_column(sa.Text, nullable=False)
+    created_at: Mapped[datetime] = mapped_column(DateTime, nullable=False, server_default=func.current_timestamp())
+    updated_at: Mapped[datetime] = mapped_column(DateTime, nullable=False, server_default=func.current_timestamp())
+
+
+class ProviderModelCredential(Base):
+    """
+    Provider model credential - stores multiple named credentials for each provider model
+    """
+
+    __tablename__ = "provider_model_credentials"
+    __table_args__ = (
+        sa.PrimaryKeyConstraint("id", name="provider_model_credential_pkey"),
+        sa.Index(
+            "provider_model_credential_tenant_provider_model_idx",
+            "tenant_id",
+            "provider_name",
+            "model_name",
+            "model_type",
+        ),
+    )
+
+    id: Mapped[str] = mapped_column(StringUUID, server_default=text("uuidv7()"))
+    tenant_id: Mapped[str] = mapped_column(StringUUID, nullable=False)
+    provider_name: Mapped[str] = mapped_column(String(255), nullable=False)
+    model_name: Mapped[str] = mapped_column(String(255), nullable=False)
+    model_type: Mapped[str] = mapped_column(String(40), nullable=False)
+    credential_name: Mapped[str] = mapped_column(String(255), nullable=False)
+    encrypted_config: Mapped[str] = mapped_column(sa.Text, nullable=False)
+    created_at: Mapped[datetime] = mapped_column(DateTime, nullable=False, server_default=func.current_timestamp())
+    updated_at: Mapped[datetime] = mapped_column(DateTime, nullable=False, server_default=func.current_timestamp())

dify_1.9.0/api/models/provider_ids.py

@@ -0,0 +1,59 @@
+"""Provider ID entities for plugin system."""
+
+import re
+
+from werkzeug.exceptions import NotFound
+
+
+class GenericProviderID:
+    organization: str
+    plugin_name: str
+    provider_name: str
+    is_hardcoded: bool
+
+    def to_string(self) -> str:
+        return str(self)
+
+    def __str__(self) -> str:
+        return f"{self.organization}/{self.plugin_name}/{self.provider_name}"
+
+    def __init__(self, value: str, is_hardcoded: bool = False) -> None:
+        if not value:
+            raise NotFound("plugin not found, please add plugin")
+        # check if the value is a valid plugin id with format: $organization/$plugin_name/$provider_name
+        if not re.match(r"^[a-z0-9_-]+\/[a-z0-9_-]+\/[a-z0-9_-]+$", value):
+            # check if matches [a-z0-9_-]+, if yes, append with langgenius/$value/$value
+            if re.match(r"^[a-z0-9_-]+$", value):
+                value = f"langgenius/{value}/{value}"
+            else:
+                raise ValueError(f"Invalid plugin id {value}")
+
+        self.organization, self.plugin_name, self.provider_name = value.split("/")
+        self.is_hardcoded = is_hardcoded
+
+    def is_langgenius(self) -> bool:
+        return self.organization == "langgenius"
+
+    @property
+    def plugin_id(self) -> str:
+        return f"{self.organization}/{self.plugin_name}"
+
+
+class ModelProviderID(GenericProviderID):
+    def __init__(self, value: str, is_hardcoded: bool = False) -> None:
+        super().__init__(value, is_hardcoded)
+        if self.organization == "langgenius" and self.provider_name == "google":
+            self.plugin_name = "gemini"
+
+
+class ToolProviderID(GenericProviderID):
+    def __init__(self, value: str, is_hardcoded: bool = False) -> None:
+        super().__init__(value, is_hardcoded)
+        if self.organization == "langgenius":
+            if self.provider_name in ["jina", "siliconflow", "stepfun", "gitee_ai"]:
+                self.plugin_name = f"{self.provider_name}_tool"
+
+
+class DatasourceProviderID(GenericProviderID):
+    def __init__(self, value: str, is_hardcoded: bool = False) -> None:
+        super().__init__(value, is_hardcoded)

dify_1.9.0/api/models/source.py

@@ -0,0 +1,59 @@
+import json
+from datetime import datetime
+
+import sqlalchemy as sa
+from sqlalchemy import DateTime, String, func
+from sqlalchemy.dialects.postgresql import JSONB
+from sqlalchemy.orm import Mapped, mapped_column
+
+from models.base import Base
+
+from .types import StringUUID
+
+
+class DataSourceOauthBinding(Base):
+    __tablename__ = "data_source_oauth_bindings"
+    __table_args__ = (
+        sa.PrimaryKeyConstraint("id", name="source_binding_pkey"),
+        sa.Index("source_binding_tenant_id_idx", "tenant_id"),
+        sa.Index("source_info_idx", "source_info", postgresql_using="gin"),
+    )
+
+    id = mapped_column(StringUUID, server_default=sa.text("uuid_generate_v4()"))
+    tenant_id = mapped_column(StringUUID, nullable=False)
+    access_token: Mapped[str] = mapped_column(String(255), nullable=False)
+    provider: Mapped[str] = mapped_column(String(255), nullable=False)
+    source_info = mapped_column(JSONB, nullable=False)
+    created_at: Mapped[datetime] = mapped_column(DateTime, nullable=False, server_default=func.current_timestamp())
+    updated_at: Mapped[datetime] = mapped_column(DateTime, nullable=False, server_default=func.current_timestamp())
+    disabled: Mapped[bool | None] = mapped_column(sa.Boolean, nullable=True, server_default=sa.text("false"))
+
+
+class DataSourceApiKeyAuthBinding(Base):
+    __tablename__ = "data_source_api_key_auth_bindings"
+    __table_args__ = (
+        sa.PrimaryKeyConstraint("id", name="data_source_api_key_auth_binding_pkey"),
+        sa.Index("data_source_api_key_auth_binding_tenant_id_idx", "tenant_id"),
+        sa.Index("data_source_api_key_auth_binding_provider_idx", "provider"),
+    )
+
+    id = mapped_column(StringUUID, server_default=sa.text("uuid_generate_v4()"))
+    tenant_id = mapped_column(StringUUID, nullable=False)
+    category: Mapped[str] = mapped_column(String(255), nullable=False)
+    provider: Mapped[str] = mapped_column(String(255), nullable=False)
+    credentials = mapped_column(sa.Text, nullable=True)  # JSON
+    created_at: Mapped[datetime] = mapped_column(DateTime, nullable=False, server_default=func.current_timestamp())
+    updated_at: Mapped[datetime] = mapped_column(DateTime, nullable=False, server_default=func.current_timestamp())
+    disabled: Mapped[bool | None] = mapped_column(sa.Boolean, nullable=True, server_default=sa.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.9.0/api/models/task.py

@@ -0,0 +1,48 @@
+from datetime import datetime
+
+import sqlalchemy as sa
+from celery import states
+from sqlalchemy import DateTime, String
+from sqlalchemy.orm import Mapped, mapped_column
+
+from libs.datetime_utils import naive_utc_now
+from models.base import Base
+
+from .engine import db
+
+
+class CeleryTask(Base):
+    """Task result/status."""
+
+    __tablename__ = "celery_taskmeta"
+
+    id = mapped_column(sa.Integer, sa.Sequence("task_id_sequence"), primary_key=True, autoincrement=True)
+    task_id = mapped_column(String(155), unique=True)
+    status = mapped_column(String(50), default=states.PENDING)
+    result = mapped_column(db.PickleType, nullable=True)
+    date_done = mapped_column(
+        DateTime,
+        default=lambda: naive_utc_now(),
+        onupdate=lambda: naive_utc_now(),
+        nullable=True,
+    )
+    traceback = mapped_column(sa.Text, nullable=True)
+    name = mapped_column(String(155), nullable=True)
+    args = mapped_column(sa.LargeBinary, nullable=True)
+    kwargs = mapped_column(sa.LargeBinary, nullable=True)
+    worker = mapped_column(String(155), nullable=True)
+    retries: Mapped[int | None] = mapped_column(sa.Integer, nullable=True)
+    queue = mapped_column(String(155), nullable=True)
+
+
+class CeleryTaskSet(Base):
+    """TaskSet result."""
+
+    __tablename__ = "celery_tasksetmeta"
+
+    id: Mapped[int] = mapped_column(
+        sa.Integer, sa.Sequence("taskset_id_sequence"), autoincrement=True, primary_key=True
+    )
+    taskset_id = mapped_column(String(155), unique=True)
+    result = mapped_column(db.PickleType, nullable=True)
+    date_done: Mapped[datetime | None] = mapped_column(DateTime, default=lambda: naive_utc_now(), nullable=True)

dify_1.9.0/api/models/tools.py

@@ -0,0 +1,555 @@
+import json
+from collections.abc import Mapping
+from datetime import datetime
+from typing import TYPE_CHECKING, Any, cast
+from urllib.parse import urlparse
+
+import sqlalchemy as sa
+from deprecated import deprecated
+from sqlalchemy import ForeignKey, String, func
+from sqlalchemy.orm import Mapped, mapped_column
+
+from core.helper import encrypter
+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, TypeBase
+
+from .engine import db
+from .model import Account, App, Tenant
+from .types import StringUUID
+
+if TYPE_CHECKING:
+    from core.mcp.types import Tool as MCPTool
+    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
+
+
+# system level tool oauth client params (client_id, client_secret, etc.)
+class ToolOAuthSystemClient(TypeBase):
+    __tablename__ = "tool_oauth_system_clients"
+    __table_args__ = (
+        sa.PrimaryKeyConstraint("id", name="tool_oauth_system_client_pkey"),
+        sa.UniqueConstraint("plugin_id", "provider", name="tool_oauth_system_client_plugin_id_provider_idx"),
+    )
+
+    id: Mapped[str] = mapped_column(StringUUID, server_default=sa.text("uuid_generate_v4()"), init=False)
+    plugin_id: Mapped[str] = mapped_column(String(512), nullable=False)
+    provider: Mapped[str] = mapped_column(String(255), nullable=False)
+    # oauth params of the tool provider
+    encrypted_oauth_params: Mapped[str] = mapped_column(sa.Text, nullable=False)
+
+
+# tenant level tool oauth client params (client_id, client_secret, etc.)
+class ToolOAuthTenantClient(Base):
+    __tablename__ = "tool_oauth_tenant_clients"
+    __table_args__ = (
+        sa.PrimaryKeyConstraint("id", name="tool_oauth_tenant_client_pkey"),
+        sa.UniqueConstraint("tenant_id", "plugin_id", "provider", name="unique_tool_oauth_tenant_client"),
+    )
+
+    id: Mapped[str] = mapped_column(StringUUID, server_default=sa.text("uuid_generate_v4()"))
+    # tenant id
+    tenant_id: Mapped[str] = mapped_column(StringUUID, nullable=False)
+    plugin_id: Mapped[str] = mapped_column(String(512), nullable=False)
+    provider: Mapped[str] = mapped_column(String(255), nullable=False)
+    enabled: Mapped[bool] = mapped_column(sa.Boolean, nullable=False, server_default=sa.text("true"))
+    # oauth params of the tool provider
+    encrypted_oauth_params: Mapped[str] = mapped_column(sa.Text, nullable=False)
+
+    @property
+    def oauth_params(self) -> dict[str, Any]:
+        return cast(dict[str, Any], json.loads(self.encrypted_oauth_params or "{}"))
+
+
+class BuiltinToolProvider(Base):
+    """
+    This table stores the tool provider information for built-in tools for each tenant.
+    """
+
+    __tablename__ = "tool_builtin_providers"
+    __table_args__ = (
+        sa.PrimaryKeyConstraint("id", name="tool_builtin_provider_pkey"),
+        sa.UniqueConstraint("tenant_id", "provider", "name", name="unique_builtin_tool_provider"),
+    )
+
+    # id of the tool provider
+    id: Mapped[str] = mapped_column(StringUUID, server_default=sa.text("uuid_generate_v4()"))
+    name: Mapped[str] = mapped_column(
+        String(256), nullable=False, server_default=sa.text("'API KEY 1'::character varying")
+    )
+    # 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(String(256), nullable=False)
+    # credential of the tool provider
+    encrypted_credentials: Mapped[str] = mapped_column(sa.Text, nullable=True)
+    created_at: Mapped[datetime] = mapped_column(
+        sa.DateTime, nullable=False, server_default=sa.text("CURRENT_TIMESTAMP(0)")
+    )
+    updated_at: Mapped[datetime] = mapped_column(
+        sa.DateTime, nullable=False, server_default=sa.text("CURRENT_TIMESTAMP(0)")
+    )
+    is_default: Mapped[bool] = mapped_column(sa.Boolean, nullable=False, server_default=sa.text("false"))
+    # credential type, e.g., "api-key", "oauth2"
+    credential_type: Mapped[str] = mapped_column(
+        String(32), nullable=False, server_default=sa.text("'api-key'::character varying")
+    )
+    expires_at: Mapped[int] = mapped_column(sa.BigInteger, nullable=False, server_default=sa.text("-1"))
+
+    @property
+    def credentials(self) -> dict[str, Any]:
+        return cast(dict[str, Any], json.loads(self.encrypted_credentials))
+
+
+class ApiToolProvider(Base):
+    """
+    The table stores the api providers.
+    """
+
+    __tablename__ = "tool_api_providers"
+    __table_args__ = (
+        sa.PrimaryKeyConstraint("id", name="tool_api_provider_pkey"),
+        sa.UniqueConstraint("name", "tenant_id", name="unique_api_tool_provider"),
+    )
+
+    id = mapped_column(StringUUID, server_default=sa.text("uuid_generate_v4()"))
+    # name of the api provider
+    name = mapped_column(String(255), nullable=False, server_default=sa.text("'API KEY 1'::character varying"))
+    # icon
+    icon: Mapped[str] = mapped_column(String(255), nullable=False)
+    # original schema
+    schema = mapped_column(sa.Text, nullable=False)
+    schema_type_str: Mapped[str] = mapped_column(String(40), nullable=False)
+    # who created this tool
+    user_id = mapped_column(StringUUID, nullable=False)
+    # tenant id
+    tenant_id = mapped_column(StringUUID, nullable=False)
+    # description of the provider
+    description = mapped_column(sa.Text, nullable=False)
+    # json format tools
+    tools_str = mapped_column(sa.Text, nullable=False)
+    # json format credentials
+    credentials_str = mapped_column(sa.Text, nullable=False)
+    # privacy policy
+    privacy_policy = mapped_column(String(255), nullable=True)
+    # custom_disclaimer
+    custom_disclaimer: Mapped[str] = mapped_column(sa.TEXT, default="")
+
+    created_at: Mapped[datetime] = mapped_column(sa.DateTime, nullable=False, server_default=func.current_timestamp())
+    updated_at: Mapped[datetime] = mapped_column(sa.DateTime, nullable=False, server_default=func.current_timestamp())
+
+    @property
+    def schema_type(self) -> "ApiProviderSchemaType":
+        from core.tools.entities.tool_entities import ApiProviderSchemaType
+
+        return ApiProviderSchemaType.value_of(self.schema_type_str)
+
+    @property
+    def tools(self) -> list["ApiToolBundle"]:
+        from core.tools.entities.tool_bundle import ApiToolBundle
+
+        return [ApiToolBundle(**tool) for tool in json.loads(self.tools_str)]
+
+    @property
+    def credentials(self) -> dict[str, Any]:
+        return dict[str, Any](json.loads(self.credentials_str))
+
+    @property
+    def user(self) -> Account | None:
+        if not self.user_id:
+            return None
+        return db.session.query(Account).where(Account.id == self.user_id).first()
+
+    @property
+    def tenant(self) -> Tenant | None:
+        return db.session.query(Tenant).where(Tenant.id == self.tenant_id).first()
+
+
+class ToolLabelBinding(TypeBase):
+    """
+    The table stores the labels for tools.
+    """
+
+    __tablename__ = "tool_label_bindings"
+    __table_args__ = (
+        sa.PrimaryKeyConstraint("id", name="tool_label_bind_pkey"),
+        sa.UniqueConstraint("tool_id", "label_name", name="unique_tool_label_bind"),
+    )
+
+    id: Mapped[str] = mapped_column(StringUUID, server_default=sa.text("uuid_generate_v4()"), init=False)
+    # tool id
+    tool_id: Mapped[str] = mapped_column(String(64), nullable=False)
+    # tool type
+    tool_type: Mapped[str] = mapped_column(String(40), nullable=False)
+    # label name
+    label_name: Mapped[str] = mapped_column(String(40), nullable=False)
+
+
+class WorkflowToolProvider(Base):
+    """
+    The table stores the workflow providers.
+    """
+
+    __tablename__ = "tool_workflow_providers"
+    __table_args__ = (
+        sa.PrimaryKeyConstraint("id", name="tool_workflow_provider_pkey"),
+        sa.UniqueConstraint("name", "tenant_id", name="unique_workflow_tool_provider"),
+        sa.UniqueConstraint("tenant_id", "app_id", name="unique_workflow_tool_provider_app_id"),
+    )
+
+    id: Mapped[str] = mapped_column(StringUUID, server_default=sa.text("uuid_generate_v4()"))
+    # name of the workflow provider
+    name: Mapped[str] = mapped_column(String(255), nullable=False)
+    # label of the workflow provider
+    label: Mapped[str] = mapped_column(String(255), nullable=False, server_default="")
+    # icon
+    icon: Mapped[str] = mapped_column(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(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(sa.Text, nullable=False)
+    # parameter configuration
+    parameter_configuration: Mapped[str] = mapped_column(sa.Text, nullable=False, server_default="[]")
+    # privacy policy
+    privacy_policy: Mapped[str] = mapped_column(String(255), nullable=True, server_default="")
+
+    created_at: Mapped[datetime] = mapped_column(
+        sa.DateTime, nullable=False, server_default=sa.text("CURRENT_TIMESTAMP(0)")
+    )
+    updated_at: Mapped[datetime] = mapped_column(
+        sa.DateTime, nullable=False, server_default=sa.text("CURRENT_TIMESTAMP(0)")
+    )
+
+    @property
+    def user(self) -> Account | None:
+        return db.session.query(Account).where(Account.id == self.user_id).first()
+
+    @property
+    def tenant(self) -> Tenant | None:
+        return db.session.query(Tenant).where(Tenant.id == self.tenant_id).first()
+
+    @property
+    def parameter_configurations(self) -> list["WorkflowToolParameterConfiguration"]:
+        from core.tools.entities.tool_entities import WorkflowToolParameterConfiguration
+
+        return [WorkflowToolParameterConfiguration(**config) for config in json.loads(self.parameter_configuration)]
+
+    @property
+    def app(self) -> App | None:
+        return db.session.query(App).where(App.id == self.app_id).first()
+
+
+class MCPToolProvider(Base):
+    """
+    The table stores the mcp providers.
+    """
+
+    __tablename__ = "tool_mcp_providers"
+    __table_args__ = (
+        sa.PrimaryKeyConstraint("id", name="tool_mcp_provider_pkey"),
+        sa.UniqueConstraint("tenant_id", "server_url_hash", name="unique_mcp_provider_server_url"),
+        sa.UniqueConstraint("tenant_id", "name", name="unique_mcp_provider_name"),
+        sa.UniqueConstraint("tenant_id", "server_identifier", name="unique_mcp_provider_server_identifier"),
+    )
+
+    id: Mapped[str] = mapped_column(StringUUID, server_default=sa.text("uuid_generate_v4()"))
+    # name of the mcp provider
+    name: Mapped[str] = mapped_column(String(40), nullable=False)
+    # server identifier of the mcp provider
+    server_identifier: Mapped[str] = mapped_column(String(64), nullable=False)
+    # encrypted url of the mcp provider
+    server_url: Mapped[str] = mapped_column(sa.Text, nullable=False)
+    # hash of server_url for uniqueness check
+    server_url_hash: Mapped[str] = mapped_column(String(64), nullable=False)
+    # icon of the mcp provider
+    icon: Mapped[str] = mapped_column(String(255), nullable=True)
+    # tenant id
+    tenant_id: Mapped[str] = mapped_column(StringUUID, nullable=False)
+    # who created this tool
+    user_id: Mapped[str] = mapped_column(StringUUID, nullable=False)
+    # encrypted credentials
+    encrypted_credentials: Mapped[str] = mapped_column(sa.Text, nullable=True)
+    # authed
+    authed: Mapped[bool] = mapped_column(sa.Boolean, nullable=False, default=False)
+    # tools
+    tools: Mapped[str] = mapped_column(sa.Text, nullable=False, default="[]")
+    created_at: Mapped[datetime] = mapped_column(
+        sa.DateTime, nullable=False, server_default=sa.text("CURRENT_TIMESTAMP(0)")
+    )
+    updated_at: Mapped[datetime] = mapped_column(
+        sa.DateTime, nullable=False, server_default=sa.text("CURRENT_TIMESTAMP(0)")
+    )
+    timeout: Mapped[float] = mapped_column(sa.Float, nullable=False, server_default=sa.text("30"))
+    sse_read_timeout: Mapped[float] = mapped_column(sa.Float, nullable=False, server_default=sa.text("300"))
+    # encrypted headers for MCP server requests
+    encrypted_headers: Mapped[str | None] = mapped_column(sa.Text, nullable=True)
+
+    def load_user(self) -> Account | None:
+        return db.session.query(Account).where(Account.id == self.user_id).first()
+
+    @property
+    def tenant(self) -> Tenant | None:
+        return db.session.query(Tenant).where(Tenant.id == self.tenant_id).first()
+
+    @property
+    def credentials(self) -> dict[str, Any]:
+        try:
+            return cast(dict[str, Any], json.loads(self.encrypted_credentials)) or {}
+        except Exception:
+            return {}
+
+    @property
+    def mcp_tools(self) -> list["MCPTool"]:
+        from core.mcp.types import Tool as MCPTool
+
+        return [MCPTool(**tool) for tool in json.loads(self.tools)]
+
+    @property
+    def provider_icon(self) -> Mapping[str, str] | str:
+        from core.file import helpers as file_helpers
+
+        try:
+            return json.loads(self.icon)
+        except json.JSONDecodeError:
+            return file_helpers.get_signed_file_url(self.icon)
+
+    @property
+    def decrypted_server_url(self) -> str:
+        return encrypter.decrypt_token(self.tenant_id, self.server_url)
+
+    @property
+    def decrypted_headers(self) -> dict[str, Any]:
+        """Get decrypted headers for MCP server requests."""
+        from core.entities.provider_entities import BasicProviderConfig
+        from core.helper.provider_cache import NoOpProviderCredentialCache
+        from core.tools.utils.encryption import create_provider_encrypter
+
+        try:
+            if not self.encrypted_headers:
+                return {}
+
+            headers_data = json.loads(self.encrypted_headers)
+
+            # Create dynamic config for all headers as SECRET_INPUT
+            config = [BasicProviderConfig(type=BasicProviderConfig.Type.SECRET_INPUT, name=key) for key in headers_data]
+
+            encrypter_instance, _ = create_provider_encrypter(
+                tenant_id=self.tenant_id,
+                config=config,
+                cache=NoOpProviderCredentialCache(),
+            )
+
+            result = encrypter_instance.decrypt(headers_data)
+            return result
+        except Exception:
+            return {}
+
+    @property
+    def masked_headers(self) -> dict[str, Any]:
+        """Get masked headers for frontend display."""
+        from core.entities.provider_entities import BasicProviderConfig
+        from core.helper.provider_cache import NoOpProviderCredentialCache
+        from core.tools.utils.encryption import create_provider_encrypter
+
+        try:
+            if not self.encrypted_headers:
+                return {}
+
+            headers_data = json.loads(self.encrypted_headers)
+
+            # Create dynamic config for all headers as SECRET_INPUT
+            config = [BasicProviderConfig(type=BasicProviderConfig.Type.SECRET_INPUT, name=key) for key in headers_data]
+
+            encrypter_instance, _ = create_provider_encrypter(
+                tenant_id=self.tenant_id,
+                config=config,
+                cache=NoOpProviderCredentialCache(),
+            )
+
+            # First decrypt, then mask
+            decrypted_headers = encrypter_instance.decrypt(headers_data)
+            result = encrypter_instance.mask_tool_credentials(decrypted_headers)
+            return result
+        except Exception:
+            return {}
+
+    @property
+    def masked_server_url(self) -> str:
+        def mask_url(url: str, mask_char: str = "*") -> str:
+            """
+            mask the url to a simple string
+            """
+            parsed = urlparse(url)
+            base_url = f"{parsed.scheme}://{parsed.netloc}"
+
+            if parsed.path and parsed.path != "/":
+                return f"{base_url}/{mask_char * 6}"
+            else:
+                return base_url
+
+        return mask_url(self.decrypted_server_url)
+
+    @property
+    def decrypted_credentials(self) -> dict[str, Any]:
+        from core.helper.provider_cache import NoOpProviderCredentialCache
+        from core.tools.mcp_tool.provider import MCPToolProviderController
+        from core.tools.utils.encryption import create_provider_encrypter
+
+        provider_controller = MCPToolProviderController.from_db(self)
+
+        encrypter, _ = create_provider_encrypter(
+            tenant_id=self.tenant_id,
+            config=[x.to_basic_provider_config() for x in provider_controller.get_credentials_schema()],
+            cache=NoOpProviderCredentialCache(),
+        )
+
+        return encrypter.decrypt(self.credentials)
+
+
+class ToolModelInvoke(Base):
+    """
+    store the invoke logs from tool invoke
+    """
+
+    __tablename__ = "tool_model_invokes"
+    __table_args__ = (sa.PrimaryKeyConstraint("id", name="tool_model_invoke_pkey"),)
+
+    id = mapped_column(StringUUID, server_default=sa.text("uuid_generate_v4()"))
+    # who invoke this tool
+    user_id = mapped_column(StringUUID, nullable=False)
+    # tenant id
+    tenant_id = mapped_column(StringUUID, nullable=False)
+    # provider
+    provider: Mapped[str] = mapped_column(String(255), nullable=False)
+    # type
+    tool_type = mapped_column(String(40), nullable=False)
+    # tool name
+    tool_name = mapped_column(String(128), nullable=False)
+    # invoke parameters
+    model_parameters = mapped_column(sa.Text, nullable=False)
+    # prompt messages
+    prompt_messages = mapped_column(sa.Text, nullable=False)
+    # invoke response
+    model_response = mapped_column(sa.Text, nullable=False)
+
+    prompt_tokens: Mapped[int] = mapped_column(sa.Integer, nullable=False, server_default=sa.text("0"))
+    answer_tokens: Mapped[int] = mapped_column(sa.Integer, nullable=False, server_default=sa.text("0"))
+    answer_unit_price = mapped_column(sa.Numeric(10, 4), nullable=False)
+    answer_price_unit = mapped_column(sa.Numeric(10, 7), nullable=False, server_default=sa.text("0.001"))
+    provider_response_latency = mapped_column(sa.Float, nullable=False, server_default=sa.text("0"))
+    total_price = mapped_column(sa.Numeric(10, 7))
+    currency: Mapped[str] = mapped_column(String(255), nullable=False)
+    created_at = mapped_column(sa.DateTime, nullable=False, server_default=func.current_timestamp())
+    updated_at = mapped_column(sa.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__ = (
+        sa.PrimaryKeyConstraint("id", name="tool_conversation_variables_pkey"),
+        # add index for user_id and conversation_id
+        sa.Index("user_id_idx", "user_id"),
+        sa.Index("conversation_id_idx", "conversation_id"),
+    )
+
+    id = mapped_column(StringUUID, server_default=sa.text("uuid_generate_v4()"))
+    # conversation user id
+    user_id = mapped_column(StringUUID, nullable=False)
+    # tenant id
+    tenant_id = mapped_column(StringUUID, nullable=False)
+    # conversation id
+    conversation_id = mapped_column(StringUUID, nullable=False)
+    # variables pool
+    variables_str = mapped_column(sa.Text, nullable=False)
+
+    created_at = mapped_column(sa.DateTime, nullable=False, server_default=func.current_timestamp())
+    updated_at = mapped_column(sa.DateTime, nullable=False, server_default=func.current_timestamp())
+
+    @property
+    def variables(self):
+        return json.loads(self.variables_str)
+
+
+class ToolFile(TypeBase):
+    """This table stores file metadata generated in workflows,
+    not only files created by agent.
+    """
+
+    __tablename__ = "tool_files"
+    __table_args__ = (
+        sa.PrimaryKeyConstraint("id", name="tool_file_pkey"),
+        sa.Index("tool_file_conversation_id_idx", "conversation_id"),
+    )
+
+    id: Mapped[str] = mapped_column(StringUUID, server_default=sa.text("uuid_generate_v4()"), init=False)
+    # 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 | None] = mapped_column(StringUUID, nullable=True)
+    # file key
+    file_key: Mapped[str] = mapped_column(String(255), nullable=False)
+    # mime type
+    mimetype: Mapped[str] = mapped_column(String(255), nullable=False)
+    # original url
+    original_url: Mapped[str | None] = mapped_column(String(2048), nullable=True, default=None)
+    # 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__ = (
+        sa.PrimaryKeyConstraint("id", name="published_app_tool_pkey"),
+        sa.UniqueConstraint("app_id", "user_id", name="unique_published_app_tool"),
+    )
+
+    id = mapped_column(StringUUID, server_default=sa.text("uuid_generate_v4()"))
+    # id of the app
+    app_id = mapped_column(StringUUID, ForeignKey("apps.id"), nullable=False)
+
+    user_id: Mapped[str] = mapped_column(StringUUID, nullable=False)
+    # who published this tool
+    description = mapped_column(sa.Text, nullable=False)
+    # llm_description of the tool, for LLM
+    llm_description = mapped_column(sa.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 = mapped_column(sa.Text, nullable=False)
+    # query name, the name of the query parameter
+    query_name = mapped_column(String(40), nullable=False)
+    # name of the tool provider
+    tool_name = mapped_column(String(40), nullable=False)
+    # author
+    author = mapped_column(String(40), nullable=False)
+    created_at = mapped_column(sa.DateTime, nullable=False, server_default=sa.text("CURRENT_TIMESTAMP(0)"))
+    updated_at = mapped_column(sa.DateTime, nullable=False, server_default=sa.text("CURRENT_TIMESTAMP(0)"))
+
+    @property
+    def description_i18n(self) -> "I18nObject":
+        from core.tools.entities.common_entities import I18nObject
+
+        return I18nObject(**json.loads(self.description))

dify_1.9.0/api/models/types.py

@@ -0,0 +1,79 @@
+import enum
+import uuid
+from typing import Any, Generic, TypeVar
+
+from sqlalchemy import CHAR, VARCHAR, TypeDecorator
+from sqlalchemy.dialects.postgresql import UUID
+from sqlalchemy.engine.interfaces import Dialect
+from sqlalchemy.sql.type_api import TypeEngine
+
+
+class StringUUID(TypeDecorator[uuid.UUID | str | None]):
+    impl = CHAR
+    cache_ok = True
+
+    def process_bind_param(self, value: uuid.UUID | str | None, dialect: Dialect) -> str | None:
+        if value is None:
+            return value
+        elif dialect.name == "postgresql":
+            return str(value)
+        else:
+            if isinstance(value, uuid.UUID):
+                return value.hex
+            return value
+
+    def load_dialect_impl(self, dialect: Dialect) -> TypeEngine[Any]:
+        if dialect.name == "postgresql":
+            return dialect.type_descriptor(UUID())
+        else:
+            return dialect.type_descriptor(CHAR(36))
+
+    def process_result_value(self, value: uuid.UUID | str | None, dialect: Dialect) -> str | None:
+        if value is None:
+            return value
+        return str(value)
+
+
+_E = TypeVar("_E", bound=enum.StrEnum)
+
+
+class EnumText(TypeDecorator[_E | None], Generic[_E]):
+    impl = VARCHAR
+    cache_ok = True
+
+    _length: int
+    _enum_class: type[_E]
+
+    def __init__(self, enum_class: type[_E], length: int | None = None):
+        self._enum_class = enum_class
+        max_enum_value_len = max(len(e.value) for e in enum_class)
+        if length is not None:
+            if length < max_enum_value_len:
+                raise ValueError("length should be greater than enum value length.")
+            self._length = length
+        else:
+            # leave some rooms for future longer enum values.
+            self._length = max(max_enum_value_len, 20)
+
+    def process_bind_param(self, value: _E | str | None, dialect: Dialect) -> str | None:
+        if value is None:
+            return value
+        if isinstance(value, self._enum_class):
+            return value.value
+        # Since _E is bound to StrEnum which inherits from str, at this point value must be str
+        self._enum_class(value)
+        return value
+
+    def load_dialect_impl(self, dialect: Dialect) -> TypeEngine[Any]:
+        return dialect.type_descriptor(VARCHAR(self._length))
+
+    def process_result_value(self, value: str | None, dialect: Dialect) -> _E | None:
+        if value is None:
+            return value
+        # Type annotation guarantees value is str at this point
+        return self._enum_class(value)
+
+    def compare_values(self, x: _E | None, y: _E | None) -> bool:
+        if x is None or y is None:
+            return x is y
+        return x == y

dify_1.9.0/api/models/web.py

@@ -0,0 +1,49 @@
+from datetime import datetime
+
+import sqlalchemy as sa
+from sqlalchemy import DateTime, String, 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__ = (
+        sa.PrimaryKeyConstraint("id", name="saved_message_pkey"),
+        sa.Index("saved_message_message_idx", "app_id", "message_id", "created_by_role", "created_by"),
+    )
+
+    id = mapped_column(StringUUID, server_default=sa.text("uuid_generate_v4()"))
+    app_id = mapped_column(StringUUID, nullable=False)
+    message_id = mapped_column(StringUUID, nullable=False)
+    created_by_role = mapped_column(
+        String(255), nullable=False, server_default=sa.text("'end_user'::character varying")
+    )
+    created_by = mapped_column(StringUUID, nullable=False)
+    created_at: Mapped[datetime] = mapped_column(DateTime, nullable=False, server_default=func.current_timestamp())
+
+    @property
+    def message(self):
+        return db.session.query(Message).where(Message.id == self.message_id).first()
+
+
+class PinnedConversation(Base):
+    __tablename__ = "pinned_conversations"
+    __table_args__ = (
+        sa.PrimaryKeyConstraint("id", name="pinned_conversation_pkey"),
+        sa.Index("pinned_conversation_conversation_idx", "app_id", "conversation_id", "created_by_role", "created_by"),
+    )
+
+    id = mapped_column(StringUUID, server_default=sa.text("uuid_generate_v4()"))
+    app_id = mapped_column(StringUUID, nullable=False)
+    conversation_id: Mapped[str] = mapped_column(StringUUID)
+    created_by_role = mapped_column(
+        String(255), nullable=False, server_default=sa.text("'end_user'::character varying")
+    )
+    created_by = mapped_column(StringUUID, nullable=False)
+    created_at: Mapped[datetime] = mapped_column(DateTime, nullable=False, server_default=func.current_timestamp())