chore: 纳入本地 Dify 1.19.0 源码及品牌与免登改动

演示目录只保留可重建的源码。运行密钥、数据卷、依赖和带口令的本地配置不进入仓库。

Co-authored-by: Cursor <cursoragent@cursor.com>
This commit is contained in:
wuzilongandCursor committed 2026-11-18 13:59:25 +08:00
1 parent 60158935f4
commit 6519682885
15831 files changed
+3063428

No files matched your search

Whitespace-only changes.
@@ -0,0 +1,18 @@
from typing import TypedDict
from graphon.variables.segments import Segment
from graphon.variables.types import SegmentType
class _VarTypedDict(TypedDict, total=False):
value_type: SegmentType
def serialize_value_type(v: _VarTypedDict | Segment) -> str:
if isinstance(v, Segment):
return str(v.value_type.exposed_type())
else:
value_type = v.get("value_type")
if value_type is None:
raise ValueError("value_type is required but not provided")
return str(value_type.exposed_type())
+479
View File
@@ -0,0 +1,479 @@
from datetime import datetime
from typing import Literal
from pydantic import Field, field_validator
from fields.base import ResponseModel
from libs.helper import to_timestamp
from models.agent import (
AgentConfigDraftType,
AgentConfigRevisionOperation,
AgentIconType,
AgentKind,
AgentScope,
AgentSource,
AgentStatus,
WorkflowAgentBindingType,
)
from models.agent_config_entities import (
AgentCliToolConfig,
AgentHumanContactConfig,
AgentKnowledgeDatasetConfig,
AgentSoulConfig,
DeclaredOutputConfig,
DeclaredOutputType,
WorkflowNodeJobConfig,
WorkflowPreviousNodeOutputRef,
)
from services.entities.agent_entities import (
ComposerCandidateCapabilities,
ComposerSaveStrategy,
ComposerVariant,
)
class AgentConfigSnapshotSummaryResponse(ResponseModel):
id: str
agent_id: str | None = None
# User-facing version number among visible published versions.
version: int
# Alias for the user-facing version number; kept explicit for clients that
# want to distinguish it from the immutable snapshot sequence.
display_version: int | None = None
# Immutable snapshot sequence number used internally for audit/history.
snapshot_version: int | None = None
summary: str | None = None
version_note: str | None = None
created_by: str | None = None
created_at: int | None = None
class AgentConfigDraftSummaryResponse(ResponseModel):
id: str
agent_id: str
draft_type: AgentConfigDraftType
account_id: str | None = None
base_snapshot_id: str | None = None
created_by: str | None = None
updated_by: str | None = None
created_at: int | None = None
updated_at: int | None = None
class AgentPublishedReferenceResponse(ResponseModel):
app_id: str
app_name: str
app_icon_type: str | None = None
app_icon: str | None = None
app_icon_background: str | None = None
app_mode: str
app_updated_at: int | None = None
workflow_id: str
workflow_version: str
node_ids: list[str] = Field(default_factory=list)
class AgentRosterResponse(ResponseModel):
id: str
name: str
description: str
role: str = ""
icon_type: AgentIconType | None = None
icon: str | None = None
icon_background: str | None = None
agent_kind: AgentKind
scope: AgentScope
source: AgentSource
app_id: str | None = None
backing_app_id: str | None = None
hidden_app_backed: bool = False
workflow_id: str | None = None
workflow_node_id: str | None = None
active_config_snapshot_id: str | None = None
active_config_snapshot: AgentConfigSnapshotSummaryResponse | None = None
active_config_is_published: bool = False
status: AgentStatus
created_by: str | None = None
updated_by: str | None = None
archived_by: str | None = None
archived_at: int | None = None
created_at: int | None = None
updated_at: int | None = None
reference_count: int | None = None
published_reference_count: int = 0
published_node_reference_count: int = 0
published_references: list[AgentPublishedReferenceResponse] = Field(default_factory=list)
class AgentInviteOptionResponse(AgentRosterResponse):
is_in_current_workflow: bool = False
in_current_workflow_count: int = 0
existing_node_ids: list[str] = Field(default_factory=list)
class AgentRosterListResponse(ResponseModel):
data: list[AgentRosterResponse]
page: int
limit: int
total: int
has_more: bool
class AgentInviteOptionsResponse(ResponseModel):
data: list[AgentInviteOptionResponse]
page: int
limit: int
total: int
has_more: bool
class AgentLogSourceResponse(ResponseModel):
id: str
type: Literal["webapp", "workflow"]
app_id: str
app_name: str
app_icon_type: str | None = None
app_icon: str | None = None
app_icon_background: str | None = None
workflow_id: str | None = None
workflow_version: str | None = None
node_id: str | None = None
class AgentLogSourceGroupResponse(ResponseModel):
type: Literal["webapp", "workflow"]
label: str
sources: list[AgentLogSourceResponse] = Field(default_factory=list)
class AgentLogSourceListResponse(ResponseModel):
data: list[AgentLogSourceResponse]
groups: list[AgentLogSourceGroupResponse]
class AgentLogConversationItemResponse(ResponseModel):
id: str
conversation_id: str
title: str | None = None
end_user_id: str | None = None
message_count: int
user_rate: float | None = None
operation_rate: float | None = None
unread: bool
source: AgentLogSourceResponse | None = None
status: Literal["success", "failed", "paused"]
created_at: int | None = None
updated_at: int | None = None
@field_validator("created_at", "updated_at", mode="before")
@classmethod
def _normalize_timestamp(cls, value: datetime | int | None) -> int | None:
return to_timestamp(value)
class AgentLogFeedbackResponse(ResponseModel):
rating: Literal["like", "dislike"]
content: str | None = None
from_source: Literal["user", "admin"]
class AgentLogMessageItemResponse(ResponseModel):
id: str
message_id: str
conversation_id: str
query: str
answer: str
status: str
error: str | None = None
from_end_user_id: str | None = None
from_account_id: str | None = None
feedback_enabled: bool = False
feedbacks: list[AgentLogFeedbackResponse] = Field(default_factory=list)
message_tokens: int
answer_tokens: int
total_tokens: int
total_price: str
currency: str
latency: float
created_at: int | None = None
updated_at: int | None = None
@field_validator("created_at", "updated_at", mode="before")
@classmethod
def _normalize_timestamp(cls, value: datetime | int | None) -> int | None:
return to_timestamp(value)
class AgentLogListResponse(ResponseModel):
data: list[AgentLogConversationItemResponse]
page: int
limit: int
total: int
has_more: bool
class AgentLogMessageListResponse(ResponseModel):
data: list[AgentLogMessageItemResponse]
page: int
limit: int
total: int
has_more: bool
class AgentStatisticSummaryResponse(ResponseModel):
total_messages: int
total_conversations: int
total_end_users: int
total_tokens: int
total_price: str
currency: str
average_session_interactions: float
average_response_time: float
tokens_per_second: float
user_satisfaction_rate: float
class AgentDailyMessageStatisticResponse(ResponseModel):
date: str
message_count: int
class AgentDailyConversationStatisticResponse(ResponseModel):
date: str
conversation_count: int
class AgentDailyEndUserStatisticResponse(ResponseModel):
date: str
terminal_count: int
class AgentTokenUsageStatisticResponse(ResponseModel):
date: str
token_count: int
total_price: str
currency: str
class AgentAverageSessionInteractionStatisticResponse(ResponseModel):
date: str
interactions: float
class AgentAverageResponseTimeStatisticResponse(ResponseModel):
date: str
latency: float
class AgentTokensPerSecondStatisticResponse(ResponseModel):
date: str
tps: float
class AgentUserSatisfactionRateStatisticResponse(ResponseModel):
date: str
rate: float
class AgentStatisticChartsResponse(ResponseModel):
daily_messages: list[AgentDailyMessageStatisticResponse] = Field(default_factory=list)
daily_conversations: list[AgentDailyConversationStatisticResponse] = Field(default_factory=list)
daily_end_users: list[AgentDailyEndUserStatisticResponse] = Field(default_factory=list)
token_usage: list[AgentTokenUsageStatisticResponse] = Field(default_factory=list)
average_session_interactions: list[AgentAverageSessionInteractionStatisticResponse] = Field(default_factory=list)
average_response_time: list[AgentAverageResponseTimeStatisticResponse] = Field(default_factory=list)
tokens_per_second: list[AgentTokensPerSecondStatisticResponse] = Field(default_factory=list)
user_satisfaction_rate: list[AgentUserSatisfactionRateStatisticResponse] = Field(default_factory=list)
class AgentStatisticSummaryEnvelopeResponse(ResponseModel):
source: str
summary: AgentStatisticSummaryResponse
charts: AgentStatisticChartsResponse
class AgentConfigRevisionResponse(ResponseModel):
id: str
previous_snapshot_id: str | None = None
current_snapshot_id: str
revision: int
operation: AgentConfigRevisionOperation
summary: str | None = None
version_note: str | None = None
created_by: str | None = None
created_at: int | None = None
class AgentConfigSnapshotDetailResponse(AgentConfigSnapshotSummaryResponse):
config_snapshot: AgentSoulConfig
revisions: list[AgentConfigRevisionResponse] = Field(default_factory=list)
class AgentConfigSnapshotListResponse(ResponseModel):
data: list[AgentConfigSnapshotSummaryResponse]
class AgentConfigSnapshotRestoreResponse(ResponseModel):
result: Literal["success"]
active_config_snapshot_id: str
draft_config_id: str | None = None
restored_version_id: str | None = None
class AgentComposerAgentResponse(ResponseModel):
id: str
name: str
description: str
role: str | None = None
icon_type: str | None = None
icon: str | None = None
icon_background: str | None = None
scope: AgentScope
source: AgentSource | None = None
status: AgentStatus
app_id: str | None = None
backing_app_id: str | None = None
hidden_app_backed: bool = False
active_config_snapshot_id: str | None = None
class AgentComposerBindingResponse(ResponseModel):
id: str
binding_type: WorkflowAgentBindingType
agent_id: str | None = None
current_snapshot_id: str | None = None
workflow_id: str
node_id: str
class AgentComposerSoulLockResponse(ResponseModel):
locked: bool
can_unlock: bool = False
reason: str | None = None
class AgentComposerImpactBindingResponse(ResponseModel):
app_id: str
workflow_id: str
node_id: str
class AgentComposerImpactResponse(ResponseModel):
current_snapshot_id: str | None = None
workflow_node_count: int
bindings: list[AgentComposerImpactBindingResponse] = Field(default_factory=list)
class WorkflowAgentComposerResponse(ResponseModel):
variant: Literal[ComposerVariant.WORKFLOW]
agent: AgentComposerAgentResponse | None = None
active_config_snapshot: AgentConfigSnapshotSummaryResponse | None = None
binding: AgentComposerBindingResponse | None = None
soul_lock: AgentComposerSoulLockResponse
agent_soul: AgentSoulConfig
node_job: WorkflowNodeJobConfig
effective_declared_outputs: list[DeclaredOutputConfig] = Field(default_factory=list)
save_options: list[ComposerSaveStrategy]
impact_summary: AgentComposerImpactResponse | None = None
validation: "ComposerValidationFindingsResponse | None" = None
app_id: str | None = None
backing_app_id: str | None = None
hidden_app_backed: bool = False
chat_endpoint: str | None = None
debug_conversation_id: str | None = None
debug_conversation_has_messages: bool = False
debug_conversation_message_count: int = 0
workflow_id: str | None = None
node_id: str | None = None
class AgentAppComposerResponse(ResponseModel):
variant: Literal[ComposerVariant.AGENT_APP]
agent: AgentComposerAgentResponse
active_config_snapshot: AgentConfigSnapshotSummaryResponse | None = None
active_config_is_published: bool
draft: AgentConfigDraftSummaryResponse | None = None
agent_soul: AgentSoulConfig
save_options: list[ComposerSaveStrategy]
validation: "ComposerValidationFindingsResponse | None" = None
app_id: str | None = None
backing_app_id: str | None = None
hidden_app_backed: bool = False
chat_endpoint: str | None = None
class ComposerValidationWarningResponse(ResponseModel):
code: str
surface: str | None = None
kind: str | None = None
id: str | None = None
message: str | None = None
class ComposerKnowledgePlaceholderResponse(ResponseModel):
id: str
placeholder_name: str
class ComposerValidationFindingsResponse(ResponseModel):
warnings: list[ComposerValidationWarningResponse] = Field(default_factory=list)
knowledge_retrieval_placeholder: list[ComposerKnowledgePlaceholderResponse] = Field(default_factory=list)
class AgentComposerValidateResponse(ResponseModel):
result: Literal["success"]
errors: list[str] = Field(default_factory=list)
warnings: list[ComposerValidationWarningResponse] = Field(default_factory=list)
knowledge_retrieval_placeholder: list[ComposerKnowledgePlaceholderResponse] = Field(default_factory=list)
class AgentComposerDifyToolCandidateResponse(ResponseModel):
id: str | None = None
# "provider" = the whole provider (all of its tools, id "<provider>/*");
# "tool" = one tool (id "<provider>/<tool_name>"). See ENG-616.
granularity: str | None = None
name: str | None = None
description: str | None = None
provider: str | None = None
provider_id: str | None = None
plugin_id: str | None = None
tools_count: int | None = None
class AgentComposerNodeJobCandidatesResponse(ResponseModel):
previous_node_outputs: list[WorkflowPreviousNodeOutputRef] = Field(default_factory=list)
declare_output_types: list[DeclaredOutputType] = Field(default_factory=list)
human_contacts: list[AgentHumanContactConfig] = Field(default_factory=list)
class AgentComposerKnowledgeDatasetCandidateResponse(AgentKnowledgeDatasetConfig):
missing: bool = False
class AgentComposerKnowledgeSetCandidateResponse(ResponseModel):
id: str
name: str
description: str | None = None
control_space_id: str | None = None
missing: bool = False
datasets: list[AgentComposerKnowledgeDatasetCandidateResponse] = Field(default_factory=list)
missing_dataset_ids: list[str] = Field(default_factory=list)
class AgentComposerSoulCandidatesResponse(ResponseModel):
dify_tools: list[AgentComposerDifyToolCandidateResponse] = Field(default_factory=list)
cli_tools: list[AgentCliToolConfig] = Field(default_factory=list)
knowledge_sets: list[AgentComposerKnowledgeSetCandidateResponse] = Field(default_factory=list)
human_contacts: list[AgentHumanContactConfig] = Field(default_factory=list)
class AgentComposerCandidatesResponse(ResponseModel):
variant: ComposerVariant
allowed_node_job_candidates: AgentComposerNodeJobCandidatesResponse = Field(
default_factory=AgentComposerNodeJobCandidatesResponse
)
allowed_soul_candidates: AgentComposerSoulCandidatesResponse = Field(
default_factory=AgentComposerSoulCandidatesResponse
)
capabilities: ComposerCandidateCapabilities = Field(default_factory=ComposerCandidateCapabilities)
truncated: bool = False
@@ -0,0 +1,69 @@
from __future__ import annotations
from datetime import datetime
from typing import Annotated
from pydantic import Field, WithJsonSchema, field_validator
from fields.base import ResponseModel
from libs.helper import to_timestamp
UUIDString = Annotated[str, WithJsonSchema({"format": "uuid", "type": "string"})]
Int64 = Annotated[int, WithJsonSchema({"format": "int64", "type": "integer"})]
class Annotation(ResponseModel):
id: UUIDString
question: str | None = None
answer: str | None = Field(default=None, validation_alias="content")
hit_count: int | None = None
created_at: Int64 | None = None
@field_validator("created_at", mode="before")
@classmethod
def _normalize_created_at(cls, value: datetime | int | None) -> int | None:
return to_timestamp(value)
class AnnotationList(ResponseModel):
data: list[Annotation]
has_more: bool
limit: int
total: int
page: int
class AnnotationJobStatusResponse(ResponseModel):
job_id: UUIDString
job_status: str
class AnnotationJobStatusDetailResponse(AnnotationJobStatusResponse):
error_msg: str = ""
class AnnotationExportList(ResponseModel):
data: list[Annotation]
class AnnotationHitHistory(ResponseModel):
id: str
source: str | None = None
score: float | None = None
question: str | None = None
created_at: int | None = None
match: str | None = Field(default=None, validation_alias="annotation_question")
response: str | None = Field(default=None, validation_alias="annotation_content")
@field_validator("created_at", mode="before")
@classmethod
def _normalize_created_at(cls, value: datetime | int | None) -> int | None:
return to_timestamp(value)
class AnnotationHitHistoryList(ResponseModel):
data: list[AnnotationHitHistory]
has_more: bool
limit: int
total: int
page: int
@@ -0,0 +1,62 @@
"""Response contracts shared by Console API key endpoints."""
from collections.abc import Iterable, Mapping
from datetime import datetime
from pydantic import field_validator
from fields.base import ResponseModel
from libs.helper import to_timestamp
class ApiKeyItem(ResponseModel):
id: str
type: str
token: str
# Dataset keys only: the knowledge bases this key is bound to. Empty = the key can
# access every knowledge base in the tenant when both scopes are empty. App keys are always empty.
dataset_ids: list[str] = []
knowledge_space_ids: list[str] = []
last_used_at: int | None = None
created_at: int | None = None
@field_validator("last_used_at", "created_at", mode="before")
@classmethod
def _normalize_timestamp(cls, value: datetime | int | None) -> int | None:
return to_timestamp(value)
class ApiKeyList(ResponseModel):
data: list[ApiKeyItem]
def mask_api_token(token: str) -> str:
"""Mask a secret token for list responses.
Reveal-once: the full secret is only returned by the create endpoint. List
endpoints expose just enough (prefix + last 4) to identify a key, never the
full value, so an existing key's secret cannot be retrieved after creation.
"""
if len(token) <= 8:
return "***"
return f"{token[:5]}...{token[-4:]}"
def build_masked_api_key_list(
api_tokens: Iterable[object],
bindings_by_token: Mapping[str, list[str]] | None = None,
) -> ApiKeyList:
"""Build an ApiKeyList from token records with their secrets masked.
``bindings_by_token`` maps an api_token id to the dataset ids it is bound to
(from DatasetApiTokenBinding); tokens absent from the map are unbound (empty =
access all). When omitted, preserve the scope carried by the records.
"""
items: list[ApiKeyItem] = []
for api_token in api_tokens:
item = ApiKeyItem.model_validate(api_token, from_attributes=True)
item.token = mask_api_token(item.token)
if bindings_by_token is not None:
item.dataset_ids = bindings_by_token.get(item.id, [])
items.append(item)
return ApiKeyList(data=items)
+246
View File
@@ -0,0 +1,246 @@
"""Shared Console app response schemas for materialized application results."""
from datetime import datetime
from pydantic import AliasChoices, Field, computed_field, field_validator
from enums import WebAppAccessMode
from fields.app_model_config_response import AppModelConfigResponse, AppModelSelectionResponse
from fields.base import ResponseModel
from libs.helper import build_icon_url, to_timestamp
from models.enums import CustomizeTokenStrategy
from models.model import AppMode, IconType
from services.entities.app_entities import RecentAppMode
from services.entities.dsl_entities import DslImportWarning, ImportStatus
class AppTraceResponse(ResponseModel):
enabled: bool = False
tracing_provider: str | None = None
capture_content: bool = False
capture_agent: bool = True
class Tag(ResponseModel):
id: str
name: str
type: str
class WorkflowPartial(ResponseModel):
id: str
created_by: str | None = None
created_at: int | None = None
updated_by: str | None = None
updated_at: int | None = None
@field_validator("created_at", "updated_at", mode="before")
@classmethod
def _normalize_timestamp(cls, value: datetime | int | None) -> int | None:
return to_timestamp(value)
class ModelConfigPartial(ResponseModel):
model: AppModelSelectionResponse | None = Field(default=None, validation_alias=AliasChoices("model_dict", "model"))
pre_prompt: str | None = None
created_by: str | None = None
created_at: int | None = None
updated_by: str | None = None
updated_at: int | None = None
@field_validator("created_at", "updated_at", mode="before")
@classmethod
def _normalize_timestamp(cls, value: datetime | int | None) -> int | None:
return to_timestamp(value)
class AppDetailSiteResponse(ResponseModel):
access_token: str | None = Field(validation_alias="code")
code: str | None
title: str
icon_type: IconType | None
icon: str | None
icon_background: str | None
description: str | None
default_language: str
chat_color_theme: str | None
chat_color_theme_inverted: bool
customize_domain: str | None
copyright: str | None
privacy_policy: str | None
input_placeholder: str | None
custom_disclaimer: str
customize_token_strategy: CustomizeTokenStrategy
prompt_public: bool
app_base_url: str
show_workflow_steps: bool
use_icon_as_answer_icon: bool
created_by: str | None
created_at: int
updated_by: str | None
updated_at: int
@computed_field(return_type=str | None) # type: ignore
@property
def icon_url(self) -> str | None:
return build_icon_url(self.icon_type, self.icon)
@field_validator("icon_type", mode="before")
@classmethod
def _normalize_icon_type(cls, value: str | IconType | None) -> str | None:
if isinstance(value, IconType):
return value.value
return value
@field_validator("created_at", "updated_at", mode="before")
@classmethod
def _normalize_timestamp(cls, value: datetime | int | None) -> int | None:
return to_timestamp(value)
class DeletedTool(ResponseModel):
type: str
tool_name: str
provider_id: str
class AppPartial(ResponseModel):
id: str
name: str
max_active_requests: int | None = None
description: str | None = Field(default=None, validation_alias=AliasChoices("desc_or_prompt", "description"))
mode: AppMode = Field(validation_alias="mode_compatible_with_agent")
icon_type: IconType | None = None
icon: str | None = None
icon_background: str | None = None
model_config_: ModelConfigPartial | None = Field(
default=None,
validation_alias=AliasChoices("app_model_config", "model_config"),
alias="model_config",
)
workflow: WorkflowPartial | None = None
use_icon_as_answer_icon: bool | None = None
created_by: str | None = None
created_at: int | None = None
updated_by: str | None = None
updated_at: int | None = None
tags: list[Tag] = Field(default_factory=list)
access_mode: WebAppAccessMode | None = None
create_user_name: str | None = None
author_name: str | None = None
has_draft_trigger: bool | None = None
permission_keys: list[str] = Field(default_factory=list)
# For Agent App type: the roster Agent backing this app (None otherwise).
bound_agent_id: str | None = None
# For Agent App responses exposed through /agent.
app_id: str | None = None
is_starred: bool = False
maintainer: str | None = None
@computed_field(return_type=str | None) # type: ignore
@property
def icon_url(self) -> str | None:
return build_icon_url(self.icon_type, self.icon)
@field_validator("created_at", "updated_at", mode="before")
@classmethod
def _normalize_timestamp(cls, value: datetime | int | None) -> int | None:
return to_timestamp(value)
class RecentAppResponse(ResponseModel):
id: str
name: str
icon_type: IconType | None = None
icon: str | None = None
icon_background: str | None = None
mode: RecentAppMode
author_name: str | None = None
updated_at: int
permission_keys: list[str] = Field(default_factory=list)
maintainer: str | None = None
@computed_field(return_type=str | None) # type: ignore[prop-decorator]
@property
def icon_url(self) -> str | None:
return build_icon_url(self.icon_type, self.icon)
@field_validator("updated_at", mode="before")
@classmethod
def _normalize_timestamp(cls, value: datetime | int) -> int:
return to_timestamp(value)
class RecentAppListResponse(ResponseModel):
data: list[RecentAppResponse]
class AppDetail(ResponseModel):
id: str
name: str
description: str
mode: AppMode = Field(validation_alias="mode_compatible_with_agent")
icon: str | None
icon_background: str | None
enable_site: bool
enable_api: bool
model_config_: AppModelConfigResponse | None = Field(
validation_alias=AliasChoices("app_model_config", "model_config"),
alias="model_config",
)
workflow: WorkflowPartial | None
tracing: str | None
use_icon_as_answer_icon: bool
created_by: str | None
created_at: int
updated_by: str | None
updated_at: int
access_mode: WebAppAccessMode | None
tags: list[Tag]
permission_keys: list[str]
maintainer: str | None
@field_validator("created_at", "updated_at", mode="before")
@classmethod
def _normalize_timestamp(cls, value: datetime | int | None) -> int | None:
return to_timestamp(value)
class AppDetailWithSite(AppDetail):
icon_type: IconType | None
api_base_url: str
max_active_requests: int | None
deleted_tools: list[DeletedTool]
site: AppDetailSiteResponse | None
# For Agent App type: the roster Agent backing this app (None otherwise).
bound_agent_id: str | None
# For Agent App responses exposed through /agent.
app_id: str | None
@computed_field(return_type=str | None) # type: ignore
@property
def icon_url(self) -> str | None:
return build_icon_url(self.icon_type, self.icon)
class AppPagination(ResponseModel):
page: int
limit: int = Field(validation_alias=AliasChoices("per_page", "limit"))
total: int
has_more: bool = Field(validation_alias=AliasChoices("has_next", "has_more"))
data: list[AppPartial] = Field(validation_alias=AliasChoices("items", "data"))
class AppExportResponse(ResponseModel):
data: str
class AppImportResponse(ResponseModel):
id: str
status: ImportStatus
app_id: str | None = None
app_mode: AppMode | None = None
current_dsl_version: str
imported_dsl_version: str = ""
error: str = ""
warnings: list[DslImportWarning] = Field(default_factory=list)
@@ -0,0 +1,388 @@
from datetime import datetime
from typing import Literal, NotRequired, TypedDict
from pydantic import AliasChoices, ConfigDict, Field, JsonValue, field_validator, with_config
from core.entities.agent_entities import PlanningStrategy
from core.rag.entities.metadata_entities import SupportedComparisonOperator
from core.rag.rerank.rerank_type import RerankMode
from core.tools.entities.tool_entities import ToolProviderType
from fields.base import ResponseModel
from graphon.file import FileTransferMethod, FileType
from graphon.model_runtime.entities.llm_entities import LLMMode
from libs.helper import to_timestamp
from models.enums import PromptType
class AppEnabledConfigResponse(TypedDict):
enabled: bool
@with_config(ConfigDict(extra="allow"))
class AppModelSelectionResponse(TypedDict, total=False):
provider: str
name: str
mode: LLMMode | Literal[""]
completion_params: dict[str, JsonValue]
class AppSuggestedQuestionsAfterAnswerResponse(TypedDict):
enabled: bool
model: NotRequired[AppModelSelectionResponse]
prompt: NotRequired[str]
class AppTextToSpeechResponse(TypedDict):
enabled: bool
voice: NotRequired[str]
language: NotRequired[str]
autoPlay: NotRequired[Literal["enabled", "disabled"]]
class AppEmbeddingModelResponse(TypedDict):
embedding_provider_name: str
embedding_model_name: str
class AppAnnotationReplyDisabledResponse(TypedDict):
enabled: Literal[False]
class AppAnnotationReplyEnabledResponse(TypedDict):
id: str
enabled: Literal[True]
score_threshold: float
embedding_model: AppEmbeddingModelResponse
@with_config(ConfigDict(extra="allow"))
class AppSensitiveWordAvoidanceResponse(TypedDict):
enabled: bool
type: NotRequired[str]
config: NotRequired[dict[str, JsonValue]]
configs: NotRequired[list[JsonValue]]
@with_config(ConfigDict(extra="allow"))
class AppEnabledExternalDataToolResponse(TypedDict):
enabled: Literal[True]
variable: str
type: str
config: dict[str, JsonValue]
label: NotRequired[str]
icon: NotRequired[str]
icon_background: NotRequired[str]
@with_config(ConfigDict(extra="allow"))
class AppDisabledExternalDataToolResponse(TypedDict):
enabled: Literal[False]
variable: NotRequired[str]
type: NotRequired[str]
config: NotRequired[dict[str, JsonValue]]
label: NotRequired[str]
icon: NotRequired[str]
icon_background: NotRequired[str]
@with_config(ConfigDict(extra="allow"))
class AppUserInputFormConfigResponse(TypedDict):
variable: str
label: str
description: NotRequired[str]
required: NotRequired[bool]
max_length: NotRequired[int | None]
options: NotRequired[list[str]]
default: NotRequired[JsonValue]
type: NotRequired[str]
hide: NotRequired[bool]
allowed_file_types: NotRequired[list[FileType]]
allowed_file_extensions: NotRequired[list[str]]
allowed_file_upload_methods: NotRequired[list[FileTransferMethod]]
json_schema: NotRequired[str | dict[str, JsonValue] | None]
config: NotRequired[dict[str, JsonValue]]
enabled: NotRequired[bool]
icon: NotRequired[str | None]
icon_background: NotRequired[str | None]
AppTextInputFormResponse = TypedDict("AppTextInputFormResponse", {"text-input": AppUserInputFormConfigResponse})
class AppSelectFormResponse(TypedDict):
select: AppUserInputFormConfigResponse
class AppParagraphFormResponse(TypedDict):
paragraph: AppUserInputFormConfigResponse
class AppNumberFormResponse(TypedDict):
number: AppUserInputFormConfigResponse
class AppCheckboxFormResponse(TypedDict):
checkbox: AppUserInputFormConfigResponse
class AppFileFormResponse(TypedDict):
file: AppUserInputFormConfigResponse
AppFileListFormResponse = TypedDict("AppFileListFormResponse", {"file-list": AppUserInputFormConfigResponse})
class AppExternalDataToolFormResponse(TypedDict):
external_data_tool: AppUserInputFormConfigResponse
class AppJsonObjectFormResponse(TypedDict):
json_object: AppUserInputFormConfigResponse
AppUserInputFormResponse = (
AppTextInputFormResponse
| AppSelectFormResponse
| AppParagraphFormResponse
| AppNumberFormResponse
| AppCheckboxFormResponse
| AppFileFormResponse
| AppFileListFormResponse
| AppExternalDataToolFormResponse
| AppJsonObjectFormResponse
)
class AppDatasetReferenceResponse(TypedDict, total=False):
id: str
enabled: bool
class AppLegacySensitiveWordToolResponse(TypedDict):
enabled: bool
words: list[str]
canned_response: str
@with_config(ConfigDict(extra="allow"))
class AppProviderAgentToolResponse(TypedDict):
provider_type: ToolProviderType
provider_id: str
tool_name: str
tool_parameters: dict[str, JsonValue]
provider_name: NotRequired[str]
tool_label: NotRequired[str]
plugin_unique_identifier: NotRequired[str | None]
credential_id: NotRequired[str | None]
enabled: NotRequired[bool]
isDeleted: NotRequired[bool]
notAuthor: NotRequired[bool]
class AppLegacyDatasetToolResponse(TypedDict):
dataset: AppDatasetReferenceResponse
class AppLegacyGoogleSearchToolResponse(TypedDict):
google_search: dict[str, JsonValue]
class AppLegacyWebReaderToolResponse(TypedDict):
web_reader: dict[str, JsonValue]
class AppLegacyWikipediaToolResponse(TypedDict):
wikipedia: dict[str, JsonValue]
class AppLegacyCurrentDatetimeToolResponse(TypedDict):
current_datetime: dict[str, JsonValue]
AppLegacySensitiveWordToolResponseItem = TypedDict(
"AppLegacySensitiveWordToolResponseItem",
{"sensitive-word-avoidance": AppLegacySensitiveWordToolResponse},
)
AppAgentToolResponse = (
AppProviderAgentToolResponse
| AppLegacyDatasetToolResponse
| AppLegacyGoogleSearchToolResponse
| AppLegacyWebReaderToolResponse
| AppLegacyWikipediaToolResponse
| AppLegacyCurrentDatetimeToolResponse
| AppLegacySensitiveWordToolResponseItem
)
class AppAgentPromptResponse(TypedDict, total=False):
first_prompt: str
next_iteration: str
@with_config(ConfigDict(extra="allow"))
class AppAgentModeResponse(TypedDict):
enabled: bool
strategy: NotRequired[PlanningStrategy | Literal["cot", "function-calling"] | None]
tools: NotRequired[list[AppAgentToolResponse]]
prompt: NotRequired[AppAgentPromptResponse | str | None]
max_iteration: NotRequired[int]
class AppChatPromptMessageResponse(TypedDict):
text: str
role: str
class AppChatPromptConfigResponse(TypedDict, total=False):
prompt: list[AppChatPromptMessageResponse]
class AppCompletionPromptTextResponse(TypedDict):
text: str
class AppConversationHistoriesRoleResponse(TypedDict):
user_prefix: str
assistant_prefix: str
class AppCompletionPromptConfigResponse(TypedDict, total=False):
prompt: AppCompletionPromptTextResponse
conversation_histories_role: AppConversationHistoriesRoleResponse
class AppDatasetItemResponse(TypedDict):
dataset: AppDatasetReferenceResponse
class AppDatasetListResponse(TypedDict):
datasets: list[AppDatasetItemResponse]
strategy: NotRequired[str]
class AppRerankingModelResponse(TypedDict, total=False):
reranking_provider_name: str
reranking_model_name: str
class AppVectorSettingResponse(TypedDict):
vector_weight: float
embedding_provider_name: str
embedding_model_name: str
class AppKeywordSettingResponse(TypedDict):
keyword_weight: float
class AppWeightsResponse(TypedDict):
vector_setting: AppVectorSettingResponse
keyword_setting: AppKeywordSettingResponse
weight_type: NotRequired[Literal["semantic_first", "keyword_first", "customized"]]
@with_config(ConfigDict(extra="allow"))
class AppMetadataConditionResponse(TypedDict):
id: NotRequired[str]
metadata_id: NotRequired[str]
name: str
comparison_operator: SupportedComparisonOperator
value: NotRequired[str | list[str] | int | float | None]
class AppMetadataFilteringConditionsResponse(TypedDict, total=False):
logical_operator: Literal["and", "or"] | None
conditions: list[AppMetadataConditionResponse] | None
@with_config(ConfigDict(extra="allow"))
class AppDatasetConfigsResponse(TypedDict):
retrieval_model: Literal["single", "multiple"]
datasets: NotRequired[AppDatasetListResponse]
top_k: NotRequired[int]
score_threshold: NotRequired[float | None]
score_threshold_enabled: NotRequired[bool]
reranking_model: NotRequired[AppRerankingModelResponse | None]
weights: NotRequired[AppWeightsResponse | None]
reranking_enabled: NotRequired[bool]
reranking_enable: NotRequired[bool]
reranking_mode: NotRequired[RerankMode]
metadata_filtering_mode: NotRequired[Literal["disabled", "automatic", "manual"]]
metadata_model_config: NotRequired[AppModelSelectionResponse | None]
metadata_filtering_conditions: NotRequired[AppMetadataFilteringConditionsResponse | None]
class AppImageUploadResponse(TypedDict, total=False):
enabled: bool
number_limits: int
detail: Literal["low", "high"] | None
transfer_methods: list[FileTransferMethod]
class AppFileUploadResponse(TypedDict, total=False):
image: AppImageUploadResponse
enabled: bool
allowed_file_types: list[FileType]
allowed_file_extensions: list[str]
allowed_file_upload_methods: list[FileTransferMethod]
number_limits: int
class AppModelConfigResponse(ResponseModel):
opening_statement: str | None
suggested_questions: list[str] = Field(
validation_alias=AliasChoices("suggested_questions_list", "suggested_questions")
)
suggested_questions_after_answer: AppSuggestedQuestionsAfterAnswerResponse = Field(
validation_alias=AliasChoices("suggested_questions_after_answer_dict", "suggested_questions_after_answer"),
)
speech_to_text: AppEnabledConfigResponse = Field(
validation_alias=AliasChoices("speech_to_text_dict", "speech_to_text")
)
text_to_speech: AppTextToSpeechResponse = Field(
validation_alias=AliasChoices("text_to_speech_dict", "text_to_speech")
)
retriever_resource: AppEnabledConfigResponse = Field(
validation_alias=AliasChoices("retriever_resource_dict", "retriever_resource")
)
annotation_reply: AppAnnotationReplyEnabledResponse | AppAnnotationReplyDisabledResponse = Field(
validation_alias=AliasChoices("annotation_reply_dict", "annotation_reply")
)
more_like_this: AppEnabledConfigResponse = Field(
validation_alias=AliasChoices("more_like_this_dict", "more_like_this")
)
sensitive_word_avoidance: AppSensitiveWordAvoidanceResponse = Field(
validation_alias=AliasChoices("sensitive_word_avoidance_dict", "sensitive_word_avoidance")
)
external_data_tools: list[AppEnabledExternalDataToolResponse | AppDisabledExternalDataToolResponse] = Field(
validation_alias=AliasChoices("external_data_tools_list", "external_data_tools")
)
model: AppModelSelectionResponse = Field(validation_alias=AliasChoices("model_dict", "model"))
user_input_form: list[AppUserInputFormResponse] = Field(
validation_alias=AliasChoices("user_input_form_list", "user_input_form")
)
dataset_query_variable: str | None
pre_prompt: str | None
agent_mode: AppAgentModeResponse = Field(validation_alias=AliasChoices("agent_mode_dict", "agent_mode"))
prompt_type: PromptType
chat_prompt_config: AppChatPromptConfigResponse = Field(
validation_alias=AliasChoices("chat_prompt_config_dict", "chat_prompt_config")
)
completion_prompt_config: AppCompletionPromptConfigResponse = Field(
validation_alias=AliasChoices("completion_prompt_config_dict", "completion_prompt_config")
)
dataset_configs: AppDatasetConfigsResponse = Field(
validation_alias=AliasChoices("dataset_configs_dict", "dataset_configs")
)
file_upload: AppFileUploadResponse = Field(validation_alias=AliasChoices("file_upload_dict", "file_upload"))
created_by: str | None
created_at: int
updated_by: str | None
updated_at: int
@field_validator("created_at", "updated_at", mode="before")
@classmethod
def _normalize_timestamp(cls, value: datetime | int | None) -> int | None:
return to_timestamp(value)
+34
View File
@@ -0,0 +1,34 @@
from __future__ import annotations
from typing import TYPE_CHECKING
from pydantic import BaseModel, ConfigDict
if TYPE_CHECKING:
from sqlalchemy.orm import Session
class SessionResponseSource[SourceT]:
"""Wrap a model so session-backed accessors resolve during response validation.
Subclasses override the accessors that need the session as properties;
every other attribute is delegated to the wrapped model unchanged.
"""
def __init__(self, source: SourceT, *, session: Session) -> None:
self._source = source
self._session = session
def __getattr__(self, name: str) -> object:
return getattr(self._source, name) # guard-ignore: no-new-getattr -- delegates model fields
class ResponseModel(BaseModel):
model_config = ConfigDict(
from_attributes=True,
extra="ignore",
validate_by_name=True,
validate_by_alias=True,
serialize_by_alias=True,
protected_namespaces=(),
)
@@ -0,0 +1,469 @@
from __future__ import annotations
from collections.abc import Sequence
from datetime import datetime
from typing import Annotated, Any
from pydantic import Field, WithJsonSchema, field_validator, model_validator
from core.rag.entities.citation_metadata import RetrievalSourceMetadata
from fields.base import ResponseModel, SessionResponseSource
from graphon.file import File
from libs.helper import to_timestamp
from models.account import Account
from models.model import (
AppModelConfigDict,
MessageAgentThought,
MessageAnnotation,
MessageFeedback,
MessageFileInfo,
)
from models.model import (
Conversation as ConversationModel,
)
from models.model import (
Message as MessageModel,
)
type AnyJSONValue = Any
UUIDString = Annotated[str, WithJsonSchema({"format": "uuid", "type": "string"})]
Int64 = Annotated[int, WithJsonSchema({"format": "int64", "type": "integer"})]
URLString = Annotated[str, WithJsonSchema({"format": "url", "type": "string"})]
class _FeedbackResponseSource(SessionResponseSource[MessageFeedback]):
@property
def from_account(self) -> Account | None:
return self._source.from_account_with_session(session=self._session)
class _AnnotationResponseSource(SessionResponseSource[MessageAnnotation]):
@property
def account(self) -> Account | None:
return self._source.account_with_session(session=self._session)
@property
def annotation_create_account(self) -> Account | None:
return self._source.annotation_create_account_with_session(session=self._session)
class MessageResponseSource(SessionResponseSource[MessageModel]):
@property
def inputs(self) -> dict[str, Any]:
return self._source.inputs_with_session(session=self._session)
@property
def feedbacks(self) -> list[_FeedbackResponseSource]:
return [
_FeedbackResponseSource(feedback, session=self._session)
for feedback in self._source.feedbacks_with_session(session=self._session)
]
@property
def user_feedback(self) -> MessageFeedback | None:
return self._source.user_feedback_with_session(session=self._session)
@property
def annotation(self) -> _AnnotationResponseSource | None:
annotation = self._source.annotation_with_session(session=self._session)
return _AnnotationResponseSource(annotation, session=self._session) if annotation else None
@property
def annotation_hit_history(self) -> _AnnotationResponseSource | None:
annotation = self._source.annotation_hit_history_with_session(session=self._session)
return _AnnotationResponseSource(annotation, session=self._session) if annotation else None
@property
def agent_thoughts(self) -> Sequence[MessageAgentThought]:
return self._source.agent_thoughts_with_session(session=self._session)
@property
def message_files(self) -> list[MessageFileInfo]:
return self._source.message_files_with_session(session=self._session)
class ConversationResponseSource(SessionResponseSource[ConversationModel]):
@property
def inputs(self) -> dict[str, Any]:
return self._source.inputs_with_session(session=self._session)
@property
def model_config(self) -> AppModelConfigDict:
return self._source.model_config_with_session(session=self._session)
@property
def summary_or_query(self) -> str:
return self._source.summary_or_query_with_session(session=self._session)
@property
def annotated(self) -> bool:
return self._source.annotated_with_session(session=self._session)
@property
def annotation(self) -> _AnnotationResponseSource | None:
annotation = self._source.annotation_with_session(session=self._session)
return _AnnotationResponseSource(annotation, session=self._session) if annotation else None
@property
def message_count(self) -> int:
return self._source.message_count_with_session(session=self._session)
@property
def user_feedback_stats(self) -> dict[str, int]:
return self._source.user_feedback_stats_with_session(session=self._session)
@property
def admin_feedback_stats(self) -> dict[str, int]:
return self._source.admin_feedback_stats_with_session(session=self._session)
@property
def status_count(self) -> dict[str, int] | None:
return self._source.status_count_with_session(session=self._session)
@property
def first_message(self) -> MessageResponseSource | None:
message = self._source.first_message_with_session(session=self._session)
return MessageResponseSource(message, session=self._session) if message else None
@property
def from_end_user_session_id(self) -> str | None:
return self._source.from_end_user_session_id_with_session(session=self._session)
@property
def from_account_name(self) -> str | None:
return self._source.from_account_name_with_session(session=self._session)
class MessageFile(ResponseModel):
id: UUIDString
filename: str
type: str
url: URLString | None = None
mime_type: str | None = None
size: int | None = None
transfer_method: str
belongs_to: str | None = None
upload_file_id: UUIDString | None = None
@field_validator("transfer_method", mode="before")
@classmethod
def _normalize_transfer_method(cls, value: object) -> str:
if isinstance(value, str):
return value
return str(value)
class SimpleConversation(ResponseModel):
id: UUIDString
name: str
inputs: dict[str, AnyJSONValue]
status: str
introduction: str | None = None
created_at: Int64 | None = None
updated_at: Int64 | None = None
@field_validator("inputs", mode="before")
@classmethod
def _normalize_inputs(cls, value: AnyJSONValue) -> AnyJSONValue:
return format_files_contained(value)
@field_validator("created_at", "updated_at", mode="before")
@classmethod
def _normalize_timestamp(cls, value: datetime | int | None) -> int | None:
return to_timestamp(value)
class ConversationInfiniteScrollPagination(ResponseModel):
limit: int
has_more: bool
data: list[SimpleConversation]
class ConversationDelete(ResponseModel):
result: str
class ResultResponse(ResponseModel):
result: str
class SimpleAccount(ResponseModel):
id: str
name: str
email: str
class Feedback(ResponseModel):
rating: str
content: str | None = None
from_source: str
from_end_user_id: str | None = None
from_account: SimpleAccount | None = None
class ConversationAnnotation(ResponseModel):
id: str
question: str | None = None
content: str
account: SimpleAccount | None = None
created_at: int | None = None
@field_validator("created_at", mode="before")
@classmethod
def _normalize_created_at(cls, value: datetime | int | None) -> int | None:
return to_timestamp(value)
class ConversationAnnotationHitHistory(ResponseModel):
annotation_id: str = Field(validation_alias="id")
annotation_create_account: SimpleAccount | None = None
created_at: int | None = None
@field_validator("created_at", mode="before")
@classmethod
def _normalize_created_at(cls, value: datetime | int | None) -> int | None:
return to_timestamp(value)
class AgentThought(ResponseModel):
id: str
chain_id: str | None = None
message_chain_id: str | None = Field(default=None, exclude=True, validation_alias="message_chain_id")
message_id: str
position: int
thought: str | None = None
answer: str | None = None
tool: str | None = None
tool_labels: AnyJSONValue = Field(description="Labels for tools used.")
tool_input: str | None = None
created_at: int | None = None
observation: str | None = None
files: list[str]
@field_validator("created_at", mode="before")
@classmethod
def _normalize_created_at(cls, value: datetime | int | None) -> int | None:
return to_timestamp(value)
@model_validator(mode="after")
def _fallback_chain_id(self):
if self.chain_id is None and self.message_chain_id:
self.chain_id = self.message_chain_id
return self
class MessageDetail(ResponseModel):
retriever_resources: list[RetrievalSourceMetadata] = Field(default_factory=list)
id: str
conversation_id: str
inputs: dict[str, AnyJSONValue]
query: str
message: AnyJSONValue
message_tokens: int
answer: str = Field(validation_alias="re_sign_file_url_answer")
answer_tokens: int
provider_response_latency: float
from_source: str
from_end_user_id: str | None = None
from_account_id: str | None = None
feedbacks: list[Feedback]
workflow_run_id: str | None = None
annotation: ConversationAnnotation | None = None
annotation_hit_history: ConversationAnnotationHitHistory | None = None
created_at: int | None = None
agent_thoughts: list[AgentThought]
message_files: list[MessageFile]
metadata: AnyJSONValue = Field(validation_alias="message_metadata_dict")
status: str
error: str | None = None
parent_message_id: str | None = None
@field_validator("inputs", mode="before")
@classmethod
def _normalize_inputs(cls, value: AnyJSONValue) -> AnyJSONValue:
return format_files_contained(value)
@field_validator("created_at", mode="before")
@classmethod
def _normalize_created_at(cls, value: datetime | int | None) -> int | None:
return to_timestamp(value)
class FeedbackStat(ResponseModel):
like: int
dislike: int
class StatusCount(ResponseModel):
success: int
failed: int
partial_success: int
paused: int
class ConversationModelConfig(ResponseModel):
opening_statement: str | None = None
suggested_questions: AnyJSONValue | None = Field(default=None)
model: AnyJSONValue | None = Field(default=None)
user_input_form: AnyJSONValue | None = Field(default=None)
pre_prompt: str | None = None
agent_mode: AnyJSONValue | None = Field(default=None)
class SimpleModelConfig(ResponseModel):
model: AnyJSONValue | None = Field(
default=None,
validation_alias="model_dict",
)
pre_prompt: str | None = None
class SimpleMessageDetail(ResponseModel):
inputs: dict[str, AnyJSONValue]
query: str
message: str
answer: str
@field_validator("inputs", mode="before")
@classmethod
def _normalize_inputs(cls, value: AnyJSONValue) -> AnyJSONValue:
return format_files_contained(value)
@field_validator("message", mode="before")
@classmethod
def _normalize_message(cls, value: AnyJSONValue) -> str:
return message_text(value)
class Conversation(ResponseModel):
id: str
status: str
from_source: str
from_end_user_id: str | None = None
from_end_user_session_id: str | None = None
from_account_id: str | None = None
from_account_name: str | None = None
read_at: int | None = None
created_at: int | None = None
updated_at: int | None = None
annotation: ConversationAnnotation | None = None
model_config_: SimpleModelConfig | None = Field(default=None, alias="model_config")
user_feedback_stats: FeedbackStat | None = None
admin_feedback_stats: FeedbackStat | None = None
message: SimpleMessageDetail | None = Field(default=None, validation_alias="first_message")
@field_validator("read_at", "created_at", "updated_at", mode="before")
@classmethod
def _normalize_timestamp(cls, value: datetime | int | None) -> int | None:
return to_timestamp(value)
class ConversationPagination(ResponseModel):
page: int
limit: int = Field(validation_alias="per_page")
total: int
has_more: bool = Field(validation_alias="has_next")
data: list[Conversation] = Field(validation_alias="items")
class ConversationMessageDetail(ResponseModel):
id: str
status: str
from_source: str
from_end_user_id: str | None = None
from_account_id: str | None = None
created_at: int | None = None
model_config_: ConversationModelConfig | None = Field(default=None, alias="model_config")
message: MessageDetail | None = Field(default=None, validation_alias="first_message")
@field_validator("created_at", mode="before")
@classmethod
def _normalize_created_at(cls, value: datetime | int | None) -> int | None:
return to_timestamp(value)
class ConversationWithSummary(ResponseModel):
id: str
status: str
from_source: str
from_end_user_id: str | None = None
from_end_user_session_id: str | None = None
from_account_id: str | None = None
from_account_name: str | None = None
name: str
summary: str = Field(validation_alias="summary_or_query")
read_at: int | None = None
created_at: int | None = None
updated_at: int | None = None
annotated: bool
model_config_: SimpleModelConfig | None = Field(default=None, alias="model_config")
message_count: int
user_feedback_stats: FeedbackStat | None = None
admin_feedback_stats: FeedbackStat | None = None
status_count: StatusCount | None = None
@field_validator("read_at", "created_at", "updated_at", mode="before")
@classmethod
def _normalize_timestamp(cls, value: datetime | int | None) -> int | None:
return to_timestamp(value)
class ConversationWithSummaryPagination(ResponseModel):
page: int
limit: int = Field(validation_alias="per_page")
total: int
has_more: bool = Field(validation_alias="has_next")
data: list[ConversationWithSummary] = Field(validation_alias="items")
class ConversationDetail(ResponseModel):
id: str
status: str
from_source: str
from_end_user_id: str | None = None
from_account_id: str | None = None
created_at: int | None = None
updated_at: int | None = None
annotated: bool
introduction: str | None = None
model_config_: ConversationModelConfig | None = Field(default=None, alias="model_config")
message_count: int
user_feedback_stats: FeedbackStat | None = None
admin_feedback_stats: FeedbackStat | None = None
@field_validator("created_at", "updated_at", mode="before")
@classmethod
def _normalize_timestamp(cls, value: datetime | int | None) -> int | None:
return to_timestamp(value)
def format_files_contained(value: AnyJSONValue) -> AnyJSONValue:
if isinstance(value, File):
# Response payloads must preserve legacy file keys like `related_id`/`url`
# while still exposing the new graph-layer `reference` field.
return value.to_dict()
if isinstance(value, dict):
return {k: format_files_contained(v) for k, v in value.items()}
if isinstance(value, list):
return [format_files_contained(v) for v in value]
return value
def message_text(value: AnyJSONValue) -> str:
if isinstance(value, list) and value:
first = value[0]
if isinstance(first, dict):
text = first.get("text")
if isinstance(text, str):
return text
return ""
def extract_model_config(value: object | None) -> dict[str, AnyJSONValue]:
if value is None:
return {}
if isinstance(value, dict):
return value
if hasattr(value, "to_dict"):
return value.to_dict()
return {}
@@ -0,0 +1,89 @@
from __future__ import annotations
from datetime import datetime
from typing import Any
from pydantic import field_validator
from fields.base import ResponseModel
from graphon.variables.types import SegmentType
from libs.helper import to_timestamp
from ._value_type_serializer import serialize_value_type
class ConversationVariableResponse(ResponseModel):
id: str
name: str
value_type: str
value: str | None = None
description: str | None = None
created_at: int | None = None
updated_at: int | None = None
@field_validator("value_type", mode="before")
@classmethod
def _normalize_value_type(cls, value: Any) -> str:
exposed_type = getattr(value, "exposed_type", None)
if callable(exposed_type):
return str(exposed_type())
if isinstance(value, str):
try:
return str(SegmentType(value).exposed_type())
except ValueError:
return value
try:
return serialize_value_type(value)
except (AttributeError, TypeError, ValueError):
pass
try:
return serialize_value_type({"value_type": value})
except (AttributeError, TypeError, ValueError):
value_attr = getattr(value, "value", None)
if value_attr is not None:
return str(value_attr)
return str(value)
@field_validator("value", mode="before")
@classmethod
def _normalize_value(cls, value: Any | None) -> str | None:
if value is None:
return None
if isinstance(value, str):
return value
return str(value)
@field_validator("created_at", "updated_at", mode="before")
@classmethod
def _normalize_timestamp(cls, value: datetime | int | None) -> int | None:
return to_timestamp(value)
class WorkflowConversationVariableResponse(ResponseModel):
id: str
name: str
value_type: str
value: Any
description: str
@field_validator("value_type", mode="before")
@classmethod
def _serialize_value_type(cls, value: Any) -> str:
if hasattr(value, "exposed_type"):
return str(value.exposed_type())
return str(value)
class PaginatedConversationVariableResponse(ResponseModel):
page: int
limit: int
total: int
has_more: bool
data: list[ConversationVariableResponse]
class ConversationVariableInfiniteScrollPaginationResponse(ResponseModel):
limit: int
has_more: bool
data: list[ConversationVariableResponse]
+217
View File
@@ -0,0 +1,217 @@
from datetime import datetime
from typing import Literal
from pydantic import BaseModel, Field, field_validator
from core.rag.index_processor.constant.index_type import IndexTechniqueType
from core.rag.retrieval.retrieval_methods import RetrievalMethod
from fields.base import ResponseModel
from libs.helper import to_timestamp
from services.data_source.entities.notion_import import NotionPageType
class NotionEstimatePagePayload(BaseModel):
page_id: str = Field(min_length=1)
page_type: NotionPageType = Field(alias="type")
class NotionEstimateWorkspacePayload(BaseModel):
workspace_id: str = Field(min_length=1)
credential_id: str = Field(min_length=1)
pages: list[NotionEstimatePagePayload] = Field(min_length=1)
MetadataValueType = Literal["string", "number", "time"]
# Mirror models.enums.PermissionEnum / DataSourceType / DatasetRuntimeMode; response schemas do not
# import models.
DatasetPermission = Literal["only_me", "all_team_members", "partial_members"]
DatasetDataSourceType = Literal[
"upload_file", "notion_import", "website_crawl", "local_file", "online_document", "online_drive"
]
DatasetRuntimeMode = Literal["general", "rag_pipeline"]
class DatasetMetadataResponse(ResponseModel):
id: str
type: MetadataValueType
name: str
class DatasetMetadataListItemResponse(ResponseModel):
id: str
name: str
type: MetadataValueType
count: int = 0
class DatasetMetadataListResponse(ResponseModel):
doc_metadata: list[DatasetMetadataListItemResponse]
built_in_field_enabled: bool
class DatasetMetadataBuiltInFieldResponse(ResponseModel):
name: str
type: MetadataValueType
class DatasetMetadataBuiltInFieldsResponse(ResponseModel):
fields: list[DatasetMetadataBuiltInFieldResponse]
class DatasetMetadataActionResponse(ResponseModel):
result: str = Field(description="Operation result.")
class DatasetRerankingModelResponse(ResponseModel):
reranking_provider_name: str | None = None
reranking_model_name: str | None = None
class DatasetKeywordSettingResponse(ResponseModel):
keyword_weight: float | None = None
class DatasetVectorSettingResponse(ResponseModel):
vector_weight: float | None = None
embedding_model_name: str | None = None
embedding_provider_name: str | None = None
class DatasetWeightedScoreResponse(ResponseModel):
weight_type: str | None = None
keyword_setting: DatasetKeywordSettingResponse = Field(
default_factory=DatasetKeywordSettingResponse,
description="Keyword search weight settings.",
)
vector_setting: DatasetVectorSettingResponse = Field(
default_factory=DatasetVectorSettingResponse,
description="Semantic search weight settings.",
)
@field_validator("keyword_setting", "vector_setting", mode="before")
@classmethod
def _expand_null_nested(cls, value: object) -> object:
return {} if value is None else value
class DatasetRetrievalModelResponse(ResponseModel):
search_method: RetrievalMethod
reranking_enable: bool
reranking_mode: str | None = None
reranking_model: DatasetRerankingModelResponse = Field(
default_factory=DatasetRerankingModelResponse,
description="Reranking model configuration.",
)
weights: DatasetWeightedScoreResponse | None = None
top_k: int
score_threshold_enabled: bool
score_threshold: float | None = None
@field_validator("reranking_model", mode="before")
@classmethod
def _expand_null_nested(cls, value: object) -> object:
return {} if value is None else value
class DatasetSummaryIndexSettingResponse(ResponseModel):
enable: bool | None = None
model_name: str | None = None
model_provider_name: str | None = None
summary_prompt: str | None = None
class DatasetTagResponse(ResponseModel):
id: str
name: str
type: str
class DatasetExternalKnowledgeInfoResponse(ResponseModel):
external_knowledge_id: str | None = None
external_knowledge_api_id: str | None = None
external_knowledge_api_name: str | None = None
external_knowledge_api_endpoint: str | None = None
class DatasetExternalRetrievalModelResponse(ResponseModel):
top_k: int
score_threshold: float | None = None
score_threshold_enabled: bool | None = None
class DatasetDocMetadataResponse(ResponseModel):
id: str
name: str
type: MetadataValueType
class DatasetIconInfoResponse(ResponseModel):
icon_type: str | None = None
icon: str | None = None
icon_background: str | None = None
icon_url: str | None = None
class DatasetDetailResponse(ResponseModel):
id: str
name: str
description: str | None
provider: str
permission: DatasetPermission
data_source_type: DatasetDataSourceType | None
indexing_technique: IndexTechniqueType | None
keyword_number: int | None = Field(default=None, description="Keywords extracted per chunk by the economy index.")
app_count: int
document_count: int
word_count: int
created_by: str
author_name: str | None
created_at: int
updated_by: str | None
updated_at: int
embedding_model: str | None
embedding_model_provider: str | None
embedding_available: bool | None = None
retrieval_model_dict: DatasetRetrievalModelResponse = Field(
description="Retrieval configuration for the knowledge base."
)
summary_index_setting: DatasetSummaryIndexSettingResponse = Field(
default_factory=DatasetSummaryIndexSettingResponse,
description="Summary index configuration.",
)
tags: list[DatasetTagResponse]
doc_form: str | None
external_knowledge_info: DatasetExternalKnowledgeInfoResponse = Field(
default_factory=DatasetExternalKnowledgeInfoResponse,
description=(
"Connection details for external knowledge bases. Populated when `provider` is `external`; otherwise "
"its properties are `null`."
),
)
external_retrieval_model: DatasetExternalRetrievalModelResponse | None
doc_metadata: list[DatasetDocMetadataResponse]
built_in_field_enabled: bool
pipeline_id: str | None
runtime_mode: DatasetRuntimeMode | None
chunk_structure: str | None
icon_info: DatasetIconInfoResponse = Field(
default_factory=DatasetIconInfoResponse,
description="Icon display configuration for the knowledge base.",
)
is_published: bool
total_documents: int
total_available_documents: int
enable_api: bool
is_multimodal: bool
permission_keys: list[str] = Field(default_factory=list)
maintainer: str | None = None
@field_validator("created_at", "updated_at", mode="before")
@classmethod
def _normalize_timestamp(cls, value: datetime | int | None) -> int | None:
return to_timestamp(value)
@field_validator("summary_index_setting", "external_knowledge_info", "icon_info", mode="before")
@classmethod
def _expand_null_nested(cls, value: object) -> object:
return {} if value is None else value
@@ -0,0 +1,162 @@
"""Response schemas for dataset document endpoints."""
from datetime import datetime
from typing import Any, Literal
from pydantic import AliasChoices, ConfigDict, Field, JsonValue, field_validator
from fields.base import ResponseModel
from fields.dataset_fields import MetadataValueType
from libs.helper import to_timestamp
# Mirrors models.enums.IndexingStatus; response schemas do not import models.
IndexingStatus = Literal["waiting", "parsing", "cleaning", "splitting", "indexing", "paused", "completed", "error"]
def normalize_enum(value: Any) -> Any:
if isinstance(value, str) or value is None:
return value
return getattr(value, "value", value)
class DocumentPreProcessingRuleResponse(ResponseModel):
id: str
enabled: bool
class DocumentSegmentationResponse(ResponseModel):
# Older rules store the separator as `delimiter`.
separator: str = Field(default="\n", validation_alias=AliasChoices("separator", "delimiter"))
max_tokens: int
chunk_overlap: int = 0
class DocumentProcessRulesResponse(ResponseModel):
pre_processing_rules: list[DocumentPreProcessingRuleResponse] | None = None
segmentation: DocumentSegmentationResponse | None = None
parent_mode: Literal["full-doc", "paragraph"] | None = None
subchunk_segmentation: DocumentSegmentationResponse | None = None
class DocumentProcessRuleResponse(ResponseModel):
mode: str
rules: DocumentProcessRulesResponse | None = None
class DocumentUploadFileDetailResponse(ResponseModel):
id: str
name: str
size: int
extension: str
mime_type: str | None = None
created_by: str
created_at: float
class DocumentSourceDetailResponse(ResponseModel):
"""The uploaded file for file documents; Notion and website documents repeat their source info."""
model_config = ConfigDict(extra="allow")
upload_file: DocumentUploadFileDetailResponse | None = Field(default=None, exclude_if=lambda value: value is None)
class DocumentMetadataResponse(ResponseModel):
id: str
name: str
type: MetadataValueType
value: str | int | float | None
class DocumentResponse(ResponseModel):
id: str
position: int | None = None
data_source_type: str | None = None
# Source-specific settings, written by the data source that imported the document.
data_source_info: dict[str, JsonValue] | None = Field(default=None, validation_alias="data_source_info_dict")
data_source_detail_dict: DocumentSourceDetailResponse
dataset_process_rule_id: str | None = None
name: str
created_from: str | None = None
created_by: str | None = None
created_at: int | None = None
tokens: int | None = None
indexing_status: str | None = None
error: str | None = None
enabled: bool | None = None
disabled_at: int | None = None
disabled_by: str | None = None
archived: bool | None = None
display_status: str | None = None
word_count: int | None = None
hit_count: int | None = None
doc_form: str | None = None
doc_metadata: list[DocumentMetadataResponse] = Field(default_factory=list, validation_alias="doc_metadata_details")
summary_index_status: str | None = None
need_summary: bool | None = None
@field_validator("data_source_type", "indexing_status", "display_status", "doc_form", mode="before")
@classmethod
def _normalize_enum_fields(cls, value: Any) -> Any:
return normalize_enum(value)
@field_validator("doc_metadata", mode="before")
@classmethod
def _normalize_doc_metadata(cls, value: Any) -> list[Any]:
if value is None:
return []
return value
@field_validator("created_at", "disabled_at", mode="before")
@classmethod
def _normalize_timestamp(cls, value: datetime | int | None) -> int | None:
return to_timestamp(value)
class DocumentListResponse(ResponseModel):
data: list[DocumentResponse]
has_more: bool
limit: int
total: int
page: int
class DocumentStatusResponse(ResponseModel):
id: str
indexing_status: IndexingStatus
processing_started_at: int | None
parsing_completed_at: int | None
cleaning_completed_at: int | None
splitting_completed_at: int | None
completed_at: int | None
paused_at: int | None
error: str | None
error_code: Literal["vector_space_estimate_exceeded"] | None = None
estimated_vector_space_mb: int | None = None
vector_space_limit_mb: int | None = None
stopped_at: int | None
completed_segments: int | None = None
total_segments: int | None = None
@field_validator("indexing_status", mode="before")
@classmethod
def _normalize_indexing_status(cls, value: Any) -> Any:
return normalize_enum(value)
@field_validator(
"processing_started_at",
"parsing_completed_at",
"cleaning_completed_at",
"splitting_completed_at",
"completed_at",
"paused_at",
"stopped_at",
mode="before",
)
@classmethod
def _normalize_timestamp(cls, value: datetime | int | None) -> int | None:
return to_timestamp(value)
class DocumentStatusListResponse(ResponseModel):
data: list[DocumentStatusResponse]
@@ -0,0 +1,32 @@
from __future__ import annotations
from datetime import datetime
from typing import Annotated
from pydantic import WithJsonSchema
from fields.base import ResponseModel
UUIDString = Annotated[str, WithJsonSchema({"format": "uuid", "type": "string"})]
class SimpleEndUser(ResponseModel):
id: str
type: str
is_anonymous: bool
session_id: str | None = None
class EndUserDetail(ResponseModel):
"""Full end-user detail returned by the Service API."""
id: UUIDString
tenant_id: UUIDString
app_id: UUIDString | None = None
type: str
external_user_id: str | None = None
name: str | None = None
is_anonymous: bool
session_id: str
created_at: datetime
updated_at: datetime
+81
View File
@@ -0,0 +1,81 @@
from __future__ import annotations
from datetime import datetime
from typing import Annotated
from pydantic import ConfigDict, WithJsonSchema, field_validator
from fields.base import ResponseModel
from libs.helper import to_timestamp
UUIDString = Annotated[str, WithJsonSchema({"format": "uuid", "type": "string"})]
Int64 = Annotated[int, WithJsonSchema({"format": "int64", "type": "integer"})]
class UploadConfig(ResponseModel):
file_size_limit: int
knowledge_file_size_limit: int
batch_count_limit: int
file_upload_limit: int
image_file_size_limit: int
video_file_size_limit: int
audio_file_size_limit: int
skill_file_size_limit: int
workflow_file_upload_limit: int
image_file_batch_limit: int
single_chunk_attachment_limit: int
attachment_image_file_size_limit: int
class FileResponse(ResponseModel):
id: UUIDString
reference: str | None = None
name: str
size: int
extension: str | None = None
mime_type: str | None = None
created_by: UUIDString | None = None
created_at: Int64 | None = None
preview_url: str | None = None
source_url: str | None = None
original_url: str | None = None
user_id: UUIDString | None = None
tenant_id: UUIDString | None = None
conversation_id: UUIDString | None = None
file_key: str | None = None
@field_validator("created_at", mode="before")
@classmethod
def _normalize_created_at(cls, value: datetime | int | None) -> int | None:
return to_timestamp(value)
class RemoteFileInfo(ResponseModel):
file_type: str
file_length: int
class FileWithSignedUrl(ResponseModel):
model_config = ConfigDict(json_schema_serialization_defaults_required=True)
id: str
name: str
size: int
extension: str | None = None
url: str | None = None
mime_type: str | None = None
created_by: str | None = None
created_at: int | None = None
@field_validator("created_at", mode="before")
@classmethod
def _normalize_created_at(cls, value: datetime | int | None) -> int | None:
return to_timestamp(value)
__all__ = [
"FileResponse",
"FileWithSignedUrl",
"RemoteFileInfo",
"UploadConfig",
]
@@ -0,0 +1,49 @@
"""Response DTOs shared by the AppDeploy file grant surfaces."""
from __future__ import annotations
from fields.base import ResponseModel
from services.entities.file_grant_entities import FileKind, ResolvedFileAccess
class ResolvedFileResponse(ResponseModel):
"""One requested file reference, either resolved or accounted for.
The resolve endpoint and optional mint references answer item by item so one
missing history file cannot fail a whole run. A file that exists but belongs
to another owner is reported exactly like one that never existed.
"""
id: str
ok: bool
kind: FileKind | None = None
name: str | None = None
size: int | None = None
extension: str | None = None
mime_type: str | None = None
url: str | None = None
internal_url: str | None = None
error: str | None = None
@classmethod
def from_resolved(cls, file_id: str, access: ResolvedFileAccess | None) -> ResolvedFileResponse:
"""Describe one resolved reference without performing infrastructure work."""
if access is None:
return cls(id=file_id, ok=False, error="not_found")
file = access.file
return cls(
id=file.id,
ok=True,
kind=file.kind,
name=file.name,
size=file.size,
extension=file.extension,
mime_type=file.mime_type,
url=access.external_url,
internal_url=access.internal_url,
)
__all__ = ["ResolvedFileResponse"]
@@ -0,0 +1,96 @@
from datetime import datetime
from typing import Any
from pydantic import Field, field_validator
from fields.base import ResponseModel
from libs.helper import to_timestamp
class HitTestingQuery(ResponseModel):
content: str
class HitTestingDocument(ResponseModel):
id: str
data_source_type: str
name: str
doc_type: str | None
doc_metadata: Any | None
@field_validator("data_source_type", "doc_type", mode="before")
@classmethod
def _normalize_enum_fields(cls, value: Any) -> Any:
return _normalize_enum(value)
class HitTestingSegment(ResponseModel):
id: str
position: int
document_id: str
content: str
sign_content: str | None
answer: str | None
word_count: int
tokens: int
keywords: list[str]
index_node_id: str | None
index_node_hash: str | None
hit_count: int
enabled: bool
disabled_at: int | None
disabled_by: str | None
status: str
created_by: str
created_at: int
indexing_at: int | None
completed_at: int | None
error: str | None
stopped_at: int | None
document: HitTestingDocument = Field(description="Parent document information for the matched chunk.")
@field_validator("disabled_at", "created_at", "indexing_at", "completed_at", "stopped_at", mode="before")
@classmethod
def _normalize_timestamp(cls, value: datetime | int | None) -> int | None:
return to_timestamp(value)
@field_validator("status", mode="before")
@classmethod
def _normalize_enum_fields(cls, value: Any) -> Any:
return _normalize_enum(value)
class HitTestingChildChunk(ResponseModel):
id: str
content: str
position: int
score: float
class HitTestingFile(ResponseModel):
id: str
name: str
size: int
extension: str
mime_type: str
source_url: str
class HitTestingRecord(ResponseModel):
segment: HitTestingSegment = Field(description="Matched chunk from the knowledge base.")
child_chunks: list[HitTestingChildChunk]
score: float | None
tsne_position: Any | None
files: list[HitTestingFile]
summary: str | None
class HitTestingResponse(ResponseModel):
query: HitTestingQuery = Field(description="The original query object.")
records: list[HitTestingRecord]
def _normalize_enum(value: Any) -> Any:
if isinstance(value, str) or value is None:
return value
return getattr(value, "value", value)
@@ -0,0 +1,73 @@
from __future__ import annotations
from datetime import datetime
from pydantic import Field, computed_field, field_validator
from fields.base import ResponseModel
from libs.helper import build_avatar_url, to_timestamp
class SimpleAccountResponse(ResponseModel):
id: str
name: str
email: str
class _AccountAvatarResponseMixin(ResponseModel):
avatar: str | None = None
@computed_field(return_type=str | None) # type: ignore[prop-decorator]
@property
def avatar_url(self) -> str | None:
return build_avatar_url(self.avatar)
class AccountResponse(_AccountAvatarResponseMixin):
id: str
name: str
email: str
is_password_set: bool
interface_language: str | None = None
interface_theme: str | None = None
timezone: str | None = None
last_login_at: int | None = None
last_login_ip: str | None = None
created_at: int | None = None
@field_validator("last_login_at", "created_at", mode="before")
@classmethod
def _normalize_timestamp(cls, value: datetime | int | None) -> int | None:
return to_timestamp(value)
class MemberRoleSummaryResponse(ResponseModel):
id: str
name: str
class AccountWithRoleResponse(_AccountAvatarResponseMixin):
id: str
name: str
email: str
last_login_at: int | None = None
last_active_at: int | None = None
created_at: int | None = None
role: str
roles: list[MemberRoleSummaryResponse] = Field(default_factory=list)
status: str
@field_validator("last_login_at", "last_active_at", "created_at", mode="before")
@classmethod
def _normalize_timestamp(cls, value: datetime | int | None) -> int | None:
return to_timestamp(value)
class AccountWithRoleListResponse(ResponseModel):
accounts: list[AccountWithRoleResponse]
SimpleAccount = SimpleAccountResponse
Account = AccountResponse
AccountWithRole = AccountWithRoleResponse
AccountWithRoleList = AccountWithRoleListResponse
+168
View File
@@ -0,0 +1,168 @@
from __future__ import annotations
from datetime import datetime
from decimal import Decimal
from typing import Annotated
from uuid import uuid4
from dify_agent.protocol.knowledge_fs import KnowledgeFsCitation
from pydantic import Field, WithJsonSchema, computed_field, field_validator
from core.entities.execution_extra_content import ExecutionExtraContentDomainModel
from fields.base import ResponseModel
from fields.conversation_fields import AgentThought, AnyJSONValue, MessageFile
from graphon.file import File
from libs.helper import to_timestamp
type JSONValueType = AnyJSONValue
UUIDString = Annotated[str, WithJsonSchema({"format": "uuid", "type": "string"})]
Int64 = Annotated[int, WithJsonSchema({"format": "int64", "type": "integer"})]
FloatNumber = Annotated[float, WithJsonSchema({"format": "float", "type": "number"})]
class SimpleFeedback(ResponseModel):
rating: str | None = None
class RetrieverResource(ResponseModel):
knowledge_fs_citation: KnowledgeFsCitation | None = None
id: UUIDString = Field(default_factory=lambda: str(uuid4()))
message_id: UUIDString = Field(default_factory=lambda: str(uuid4()))
position: int
dataset_id: UUIDString | None = None
dataset_name: str | None = None
document_id: UUIDString | None = None
document_asset_id: UUIDString | None = None
document_revision: int | None = None
document_version: int | None = None
document_name: str | None = None
data_source_type: str | None = None
segment_id: UUIDString | None = None
score: FloatNumber | None = None
hit_count: int | None = None
word_count: int | None = None
segment_position: int | None = None
index_node_hash: str | None = None
content: str | None = None
summary: str | None = None
created_at: Int64 | None = None
retriever_from: str | None = None
page: int | None = None
doc_metadata: dict[str, JSONValueType] | None = None
title: str | None = None
files: list[dict[str, JSONValueType]] | None = None
@field_validator("created_at", mode="before")
@classmethod
def _normalize_created_at(cls, value: datetime | int | None) -> int | None:
return to_timestamp(value)
class MessageListItem(ResponseModel):
id: UUIDString
conversation_id: UUIDString
parent_message_id: UUIDString | None = None
inputs: dict[str, JSONValueType]
query: str
answer: str = Field(validation_alias="re_sign_file_url_answer")
feedback: SimpleFeedback | None = Field(default=None, validation_alias="user_feedback")
retriever_resources: list[RetrieverResource]
created_at: Int64 | None = None
agent_thoughts: list[AgentThought]
message_files: list[MessageFile]
message_tokens: int = 0
answer_tokens: int = 0
provider_response_latency: FloatNumber = 0
total_price: Decimal | None = None
currency: str | None = None
status: str
error: str | None = None
extra_contents: list[ExecutionExtraContentDomainModel]
@computed_field
def total_tokens(self) -> int:
return self.message_tokens + self.answer_tokens
@field_validator("inputs", mode="before")
@classmethod
def _normalize_inputs(cls, value: JSONValueType) -> JSONValueType:
return format_files_contained(value)
@field_validator("created_at", mode="before")
@classmethod
def _normalize_created_at(cls, value: datetime | int | None) -> int | None:
return to_timestamp(value)
class WebMessageListItem(MessageListItem):
metadata: JSONValueType | None = Field(
default=None,
validation_alias="message_metadata_dict",
)
class ExploreMessageListItem(MessageListItem):
metadata: JSONValueType | None = Field(
default=None,
validation_alias="message_metadata_dict",
)
class MessageInfiniteScrollPagination(ResponseModel):
limit: int
has_more: bool
data: list[MessageListItem]
class WebMessageInfiniteScrollPagination(ResponseModel):
limit: int
has_more: bool
data: list[WebMessageListItem]
class ExploreMessageInfiniteScrollPagination(ResponseModel):
limit: int
has_more: bool
data: list[ExploreMessageListItem]
class SavedMessageItem(ResponseModel):
id: str
inputs: dict[str, JSONValueType]
query: str
answer: str
message_files: list[MessageFile]
feedback: SimpleFeedback | None = Field(default=None, validation_alias="user_feedback")
created_at: int | None = None
@field_validator("inputs", mode="before")
@classmethod
def _normalize_inputs(cls, value: JSONValueType) -> JSONValueType:
return format_files_contained(value)
@field_validator("created_at", mode="before")
@classmethod
def _normalize_created_at(cls, value: datetime | int | None) -> int | None:
return to_timestamp(value)
class SavedMessageInfiniteScrollPagination(ResponseModel):
limit: int
has_more: bool
data: list[SavedMessageItem]
class SuggestedQuestionsResponse(ResponseModel):
data: list[str]
def format_files_contained(value: JSONValueType) -> JSONValueType:
if isinstance(value, File):
# Response payloads must preserve legacy file keys like `related_id`/`url`
# while still exposing the new graph-layer `reference` field.
return value.to_dict()
if isinstance(value, dict):
return {k: format_files_contained(v) for k, v in value.items()}
if isinstance(value, list):
return [format_files_contained(v) for v in value]
return value
+12
View File
@@ -0,0 +1,12 @@
from pydantic import Field, PositiveInt
class PaginationParamsMixin:
page: PositiveInt = Field(1, description="1-based page number.")
limit: PositiveInt = Field(default=20, le=100, description="Maximum number of records returned per page.")
class PaginationResultMixin:
limit: int = Field(description="Page size used for the current query.")
total: int = Field(description="Total number of candidates matching the current query.")
page: int = Field(description="Current 1-based page number.")
@@ -0,0 +1,90 @@
from datetime import datetime
from typing import Literal
from pydantic import field_serializer
from fields.base import ResponseModel
from libs.helper import to_timestamp
# Mirrors models.enums.SegmentStatus / SegmentType; response schemas do not import models.
SegmentStatus = Literal["waiting", "indexing", "completed", "error", "paused", "re_segment"]
SegmentType = Literal["automatic", "customized"]
class SegmentAttachmentResponse(ResponseModel):
id: str
name: str
size: int
extension: str
mime_type: str | None
source_url: str
class ChildChunkResponse(ResponseModel):
id: str
segment_id: str
content: str
position: int
word_count: int
type: SegmentType
created_at: datetime | int
updated_at: datetime | int
@field_serializer("created_at", "updated_at")
def serialize_timestamp(self, value: datetime | int) -> int:
return to_timestamp(value)
class SegmentResponse(ResponseModel):
id: str
position: int
document_id: str
content: str
sign_content: str
answer: str | None
word_count: int
tokens: int
keywords: list[str] | None
index_node_id: str | None
index_node_hash: str | None
hit_count: int
enabled: bool
disabled_at: datetime | int | None
disabled_by: str | None
status: SegmentStatus
created_by: str
created_at: datetime | int
updated_at: datetime | int
updated_by: str | None
indexing_at: datetime | int | None
completed_at: datetime | int | None
error: str | None
stopped_at: datetime | int | None
child_chunks: list[ChildChunkResponse]
attachments: list[SegmentAttachmentResponse]
summary: str | None
@field_serializer("created_at", "updated_at")
def serialize_required_timestamp(self, value: datetime | int) -> int:
return to_timestamp(value)
@field_serializer("disabled_at", "indexing_at", "completed_at", "stopped_at")
def serialize_optional_timestamp(self, value: datetime | int | None) -> int | None:
return to_timestamp(value)
class SegmentDetailResponse(ResponseModel):
data: SegmentResponse
doc_form: str
class ChildChunkDetailResponse(ResponseModel):
data: ChildChunkResponse
class ChildChunkListResponse(ResponseModel):
data: list[ChildChunkResponse]
total: int
total_pages: int
page: int
limit: int
+127
View File
@@ -0,0 +1,127 @@
from collections.abc import Iterable
from datetime import datetime
from typing import Any
from pydantic import Field, field_validator
from sqlalchemy.orm import Session
from fields.base import ResponseModel
from fields.member_fields import SimpleAccountResponse
from libs.helper import to_timestamp
from models.snippet import CustomizedSnippet, SnippetType
class SnippetTagResponse(ResponseModel):
id: str
name: str
type: str
class SnippetListItemResponse(ResponseModel):
id: str
name: str
description: str | None
type: SnippetType
version: int
use_count: int
is_published: bool
icon_info: dict[str, Any] | None
tags: list[SnippetTagResponse]
created_by: str | None
author_name: str | None
created_at: int
updated_by: str | None
updated_at: int
@field_validator("created_at", "updated_at", mode="before")
@classmethod
def _normalize_timestamp(cls, value: datetime | int | None) -> int:
timestamp = to_timestamp(value)
if timestamp is None:
raise ValueError("timestamp is required")
return timestamp
class SnippetResponse(ResponseModel):
id: str
name: str
description: str | None
type: SnippetType
version: int
use_count: int
is_published: bool
icon_info: dict[str, Any] | None
graph: dict[str, Any] = Field(validation_alias="graph_dict")
input_fields: list[dict[str, Any]] = Field(validation_alias="input_fields_list")
tags: list[SnippetTagResponse]
created_by: SimpleAccountResponse | None = Field(validation_alias="created_by_account")
created_at: int
updated_by: SimpleAccountResponse | None = Field(validation_alias="updated_by_account")
updated_at: int
@field_validator("created_at", "updated_at", mode="before")
@classmethod
def _normalize_timestamp(cls, value: datetime | int | None) -> int:
timestamp = to_timestamp(value)
if timestamp is None:
raise ValueError("timestamp is required")
return timestamp
class SnippetPaginationResponse(ResponseModel):
data: list[SnippetListItemResponse]
page: int
limit: int
total: int
has_more: bool
def snippet_response(snippet: CustomizedSnippet, *, session: Session) -> SnippetResponse:
"""Build the snippet detail response, resolving session-backed lookups at the request boundary."""
return SnippetResponse.model_validate(
{
"id": snippet.id,
"name": snippet.name,
"description": snippet.description,
"type": snippet.type,
"version": snippet.version,
"use_count": snippet.use_count,
"is_published": snippet.is_published,
"icon_info": snippet.icon_info,
"graph": snippet.get_graph_dict(session=session),
"input_fields": snippet.input_fields_list,
"tags": snippet.get_tags(session=session),
"created_by": snippet.get_created_by_account(session=session),
"created_at": snippet.created_at,
"updated_by": snippet.get_updated_by_account(session=session),
"updated_at": snippet.updated_at,
}
)
def snippet_list_item_response(snippet: CustomizedSnippet, *, session: Session) -> SnippetListItemResponse:
"""Build one snippet list row, resolving session-backed lookups at the request boundary."""
return SnippetListItemResponse.model_validate(
{
"id": snippet.id,
"name": snippet.name,
"description": snippet.description,
"type": snippet.type,
"version": snippet.version,
"use_count": snippet.use_count,
"is_published": snippet.is_published,
"icon_info": snippet.icon_info,
"tags": snippet.get_tags(session=session),
"created_by": snippet.created_by,
"author_name": snippet.get_author_name(session=session),
"created_at": snippet.created_at,
"updated_by": snippet.updated_by,
"updated_at": snippet.updated_at,
}
)
def snippet_list_item_responses(
snippets: Iterable[CustomizedSnippet], *, session: Session
) -> list[SnippetListItemResponse]:
return [snippet_list_item_response(snippet, session=session) for snippet in snippets]
+24
View File
@@ -0,0 +1,24 @@
from datetime import datetime
from typing import Annotated
from pydantic import BeforeValidator, Field, PlainSerializer
from libs.datetime_utils import to_utc_timestamp
def _require_datetime(value: object) -> datetime:
if not isinstance(value, datetime):
raise ValueError("Timestamp source must be a datetime")
return value
def _datetime_to_unix_seconds(value: datetime) -> int:
return to_utc_timestamp(value)
Timestamp = Annotated[
datetime,
BeforeValidator(_require_datetime),
PlainSerializer(_datetime_to_unix_seconds, return_type=int, when_used="json"),
Field(..., description="Unix timestamp in seconds"),
]
@@ -0,0 +1,137 @@
from __future__ import annotations
from typing import Any, override
from pydantic import model_validator
from fields.base import ResponseModel
from graphon.file import helpers as file_helpers
from graphon.variables.segment_group import SegmentGroup
from graphon.variables.segments import ArrayFileSegment, FileSegment, Segment
from models.workflow import WorkflowDraftVariable
type RecursiveJSONValue = str | int | float | bool | dict[str, "RecursiveJSONValue"] | list["RecursiveJSONValue"] | None
def _convert_values_to_json_serializable_object(value: Segment) -> RecursiveJSONValue:
match value:
case FileSegment():
return value.value.model_dump()
case ArrayFileSegment():
return [item.model_dump() for item in value.value]
case SegmentGroup():
return [_convert_values_to_json_serializable_object(item) for item in value.value]
case _:
return value.value
def _serialize_var_value(variable: WorkflowDraftVariable) -> RecursiveJSONValue:
value = variable.get_value()
# Create a copy to avoid mutating the model's cached deserialized value.
value = value.model_copy(deep=True)
# Refresh URL signatures immediately before returning file values to the client.
match value:
case FileSegment():
value.value.remote_url = value.value.generate_url()
case ArrayFileSegment():
for file in value.value:
file.remote_url = file.generate_url()
return _convert_values_to_json_serializable_object(value)
class WorkflowDraftVariableFullContentResponse(ResponseModel):
size_bytes: int | None
value_type: str
length: int | None
download_url: str
def _serialize_full_content(
variable: WorkflowDraftVariable,
) -> WorkflowDraftVariableFullContentResponse | None:
"""Serialize metadata for a variable whose complete value was offloaded."""
if not variable.is_truncated():
return None
variable_file = variable.variable_file
assert variable_file is not None
return WorkflowDraftVariableFullContentResponse(
size_bytes=variable_file.size,
value_type=str(variable_file.value_type.exposed_type()),
length=variable_file.length,
download_url=file_helpers.get_signed_file_url(variable_file.upload_file_id, as_attachment=True),
)
def _serialize_without_value(variable: WorkflowDraftVariable) -> dict[str, Any]:
return {
"id": variable.id,
"type": str(variable.get_variable_type()),
"name": variable.name,
"description": variable.description,
"selector": variable.get_selector(),
"value_type": str(variable.value_type.exposed_type()),
"edited": variable.edited,
"visible": variable.visible,
"is_truncated": variable.is_truncated(),
}
class WorkflowDraftVariableWithoutValueResponse(ResponseModel):
id: str
type: str
name: str
description: str
selector: list[str]
value_type: str
edited: bool
visible: bool
is_truncated: bool
@model_validator(mode="before")
@classmethod
def _from_workflow_draft_variable(cls, value: Any) -> Any:
if isinstance(value, WorkflowDraftVariable):
return _serialize_without_value(value)
return value
class WorkflowDraftVariableResponse(WorkflowDraftVariableWithoutValueResponse):
value: RecursiveJSONValue
full_content: WorkflowDraftVariableFullContentResponse | None
@model_validator(mode="before")
@classmethod
@override
def _from_workflow_draft_variable(cls, value: Any) -> Any:
if isinstance(value, WorkflowDraftVariable):
return {
**_serialize_without_value(value),
"value": _serialize_var_value(value),
"full_content": _serialize_full_content(value),
}
return value
class WorkflowDraftVariableListWithoutValueResponse(ResponseModel):
items: list[WorkflowDraftVariableWithoutValueResponse]
total: int | None
@model_validator(mode="before")
@classmethod
def _from_workflow_draft_variable_list(cls, value: Any) -> Any:
if hasattr(value, "variables") and hasattr(value, "total"):
return {"items": value.variables, "total": value.total}
return value
class WorkflowDraftVariableListResponse(ResponseModel):
items: list[WorkflowDraftVariableResponse]
@model_validator(mode="before")
@classmethod
def _from_workflow_draft_variable_list(cls, value: Any) -> Any:
if hasattr(value, "variables"):
return {"items": value.variables}
return value
@@ -0,0 +1,237 @@
"""Workflow run response schemas for console APIs.
Workflow-run endpoints should document and serialize responses with the
Pydantic models in this module.
"""
from __future__ import annotations
from datetime import datetime
from enum import Enum
from typing import Any
from pydantic import AliasChoices, Field, field_validator
from sqlalchemy.orm import Session
from fields.base import ResponseModel, SessionResponseSource
from fields.end_user_fields import SimpleEndUser
from fields.member_fields import SimpleAccount
from libs.helper import to_timestamp
class WorkflowRunForLogResponse(ResponseModel):
id: str
version: str | None = None
status: str | None = None
triggered_from: str | None = None
error: str | None = None
elapsed_time: float | None = None
total_tokens: int | None = None
total_steps: int | None = None
created_at: int | None = None
finished_at: int | None = None
exceptions_count: int | None = None
@field_validator("status", mode="before")
@classmethod
def _normalize_status(cls, value: Any) -> str | None:
if value is None or isinstance(value, str):
return value
return str(getattr(value, "value", value))
@field_validator("created_at", "finished_at", mode="before")
@classmethod
def _normalize_timestamp(cls, value: datetime | int | None) -> int | None:
return to_timestamp(value)
class WorkflowRunForArchivedLogResponse(ResponseModel):
id: str
status: str | None = None
triggered_from: str | None = None
elapsed_time: float | None = None
total_tokens: int | None = None
@field_validator("status", mode="before")
@classmethod
def _normalize_status(cls, value: Any) -> str | None:
if value is None or isinstance(value, str):
return value
return str(value.value if isinstance(value, Enum) else value)
class WorkflowRunForListResponse(ResponseModel):
id: str
version: str | None = None
status: str | None = None
elapsed_time: float | None = None
total_tokens: int | None = None
total_steps: int | None = None
created_by_account: SimpleAccount | None = None
created_at: int | None = None
finished_at: int | None = None
exceptions_count: int | None = None
retry_index: int | None = None
@field_validator("status", mode="before")
@classmethod
def _normalize_status(cls, value: Any) -> str | None:
if value is None or isinstance(value, str):
return value
return str(getattr(value, "value", value))
@field_validator("created_at", "finished_at", mode="before")
@classmethod
def _normalize_timestamp(cls, value: datetime | int | None) -> int | None:
return to_timestamp(value)
class AdvancedChatWorkflowRunForListResponse(WorkflowRunForListResponse):
conversation_id: str | None = None
message_id: str | None = None
class AdvancedChatWorkflowRunPaginationResponse(ResponseModel):
limit: int
has_more: bool
data: list[AdvancedChatWorkflowRunForListResponse]
class WorkflowRunPaginationResponse(ResponseModel):
limit: int
has_more: bool
data: list[WorkflowRunForListResponse]
class WorkflowRunCountResponse(ResponseModel):
total: int
running: int
succeeded: int
failed: int
stopped: int
partial_succeeded: int = Field(
alias="partial_succeeded",
validation_alias=AliasChoices("partial_succeeded", "partial-succeeded"),
)
class WorkflowRunDetailResponse(ResponseModel):
id: str
version: str | None = None
graph: Any = Field(validation_alias="graph_dict")
inputs: Any = Field(validation_alias="inputs_dict")
status: str | None = None
outputs: Any = Field(validation_alias="outputs_dict")
error: str | None = None
elapsed_time: float | None = None
total_tokens: int | None = None
total_steps: int | None = None
created_by_role: str | None = None
created_by_account: SimpleAccount | None = None
created_by_end_user: SimpleEndUser | None = None
created_at: int | None = None
finished_at: int | None = None
exceptions_count: int | None = None
@field_validator("status", mode="before")
@classmethod
def _normalize_status(cls, value: Any) -> str | None:
if value is None or isinstance(value, str):
return value
return str(getattr(value, "value", value))
@field_validator("created_at", "finished_at", mode="before")
@classmethod
def _normalize_timestamp(cls, value: datetime | int | None) -> int | None:
return to_timestamp(value)
class WorkflowRunNodeExecutionResponse(ResponseModel):
id: str
index: int | None = None
predecessor_node_id: str | None = None
node_id: str | None = None
node_type: str | None = None
title: str | None = None
inputs: Any = Field(default=None, validation_alias="inputs_dict")
process_data: Any = Field(default=None, validation_alias="process_data_dict")
outputs: Any = Field(default=None, validation_alias="outputs_dict")
status: str | None = None
error: str | None = None
elapsed_time: float | None = None
execution_metadata: Any = Field(default=None, validation_alias="execution_metadata_dict")
extras: Any = None
created_at: int | None = None
created_by_role: str | None = None
created_by_account: SimpleAccount | None = None
created_by_end_user: SimpleEndUser | None = None
finished_at: int | None = None
inputs_truncated: bool | None = None
outputs_truncated: bool | None = None
process_data_truncated: bool | None = None
retry_index: int | None = Field(default=None, exclude_if=lambda value: value is None)
@field_validator("status", mode="before")
@classmethod
def _normalize_status(cls, value: Any) -> str | None:
if value is None or isinstance(value, str):
return value
return str(getattr(value, "value", value))
@field_validator("created_at", "finished_at", mode="before")
@classmethod
def _normalize_timestamp(cls, value: datetime | int | None) -> int | None:
return to_timestamp(value)
class WorkflowRunResponseSource(SessionResponseSource[Any]):
"""Expose session-backed workflow-run accessors during response validation."""
@property
def created_by_account(self) -> Any:
return self._source.created_by_account(self._session)
@property
def created_by_end_user(self) -> Any:
return self._source.created_by_end_user(self._session)
def workflow_run_response_source(workflow_run: Any, *, session: Session) -> WorkflowRunResponseSource:
return WorkflowRunResponseSource(workflow_run, session=session)
def workflow_run_pagination_response_source(pagination: Any, *, session: Session) -> dict[str, Any]:
"""Wrap each run in a pagination payload so list responses resolve accessors via the session."""
return {
"limit": pagination.limit,
"has_more": pagination.has_more,
"data": [workflow_run_response_source(run, session=session) for run in pagination.data],
}
class WorkflowNodeExecutionResponseSource(SessionResponseSource[Any]):
"""Expose session-backed node-execution accessors during response validation."""
@property
def created_by_account(self) -> Any:
return self._source.created_by_account(self._session)
@property
def created_by_end_user(self) -> Any:
return self._source.created_by_end_user(self._session)
def node_execution_response_source(node_execution: Any, *, session: Session) -> WorkflowNodeExecutionResponseSource:
return WorkflowNodeExecutionResponseSource(node_execution, session=session)
class WorkflowRunNodeExecutionListResponse(ResponseModel):
data: list[WorkflowRunNodeExecutionResponse]
class WorkflowToolNodeExecutionResponse(WorkflowRunNodeExecutionResponse):
node_execution_id: str | None = None
class WorkflowToolNodeExecutionListResponse(ResponseModel):
data: list[WorkflowToolNodeExecutionResponse]