deerflow-code/frontend-web/src/core/system-settings/api.ts

import { apiFetch } from "@/core/api";
import { getBackendBaseURL } from "@/core/config";
import { OptType, writeYLog } from "@/core/log/y-log";

export interface PromptPrefixSettings {
  enabled: boolean;
  switch_label: string;
  prompt_prefix: string;
  ordinary_qa_markdown_format_enabled: boolean;
}

export type KnowledgeBaseProductVersion = "v1" | "v2";

export type OrdinaryKnowledgeLanding = "wiki" | "weknora";

export async function loadOrdinaryKnowledgeLanding(): Promise<OrdinaryKnowledgeLanding> {
  const response = await apiFetch(`${getBackendBaseURL()}/api/system-settings/ordinary-knowledge-landing`);
  if (!response.ok) throw new Error("无法读取普通知识库默认页面设置");
  return ((await response.json()) as { mode: OrdinaryKnowledgeLanding }).mode;
}

export async function saveOrdinaryKnowledgeLanding(mode: OrdinaryKnowledgeLanding): Promise<OrdinaryKnowledgeLanding> {
  const response = await apiFetch(`${getBackendBaseURL()}/api/system-settings/ordinary-knowledge-landing`, {
    method: "PUT", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ mode }),
  });
  if (!response.ok) throw new Error("保存失败，仅管理员可配置普通知识库默认页面");
  return ((await response.json()) as { mode: OrdinaryKnowledgeLanding }).mode;
}

export async function loadKnowledgeBaseProductVersion(): Promise<KnowledgeBaseProductVersion> {
  const response = await apiFetch(
    `${getBackendBaseURL()}/api/system-settings/knowledge-base-product-version`,
  );
  if (!response.ok) throw new Error(`Failed to load knowledge base product version: ${response.status}`);
  return ((await response.json()) as { version: KnowledgeBaseProductVersion }).version;
}

export async function updateKnowledgeBaseProductVersion(
  version: KnowledgeBaseProductVersion,
): Promise<KnowledgeBaseProductVersion> {
  const response = await apiFetch(
    `${getBackendBaseURL()}/api/system-settings/knowledge-base-product-version`,
    {
      method: "PUT",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify({ version }),
    },
  );
  if (!response.ok) throw new Error(`Failed to update knowledge base product version: ${response.status}`);
  return ((await response.json()) as { version: KnowledgeBaseProductVersion }).version;
}

export interface PluginDomainAgentMappingDto {
  id: string;
  domain: string;
  agent_id: string;
  enabled: boolean;
}

export interface PluginManagementSettings {
  domainAgentMappings: Array<{
    id: string;
    domain: string;
    agentId: string;
    enabled: boolean;
  }>;
}

export interface PluginManagementUpdate {
  domainAgentMappings?: Array<{
    id: string;
    domain: string;
    agentId: string;
    enabled: boolean;
  }>;
}

export interface PromptPrefixUpdate {
  enabled?: boolean;
  switch_label?: string;
  prompt_prefix?: string;
  ordinary_qa_markdown_format_enabled?: boolean;
}

function fromPluginManagementDto(data: {
  domain_agent_mappings: PluginDomainAgentMappingDto[];
}): PluginManagementSettings {
  return {
    domainAgentMappings: (data.domain_agent_mappings ?? []).map((item) => ({
      id: item.id,
      domain: item.domain,
      agentId: item.agent_id,
      enabled: item.enabled,
    })),
  };
}

function toPluginManagementDto(body: PluginManagementUpdate) {
  return {
    domain_agent_mappings: (body.domainAgentMappings ?? []).map((item) => ({
      id: item.id,
      domain: item.domain,
      agent_id: item.agentId,
      enabled: item.enabled,
    })),
  };
}

export async function loadPluginManagementSettings(): Promise<PluginManagementSettings> {
  const response = await apiFetch(
    `${getBackendBaseURL()}/api/system-settings/plugin-management`,
  );
  if (!response.ok) {
    throw new Error(
      `Failed to load plugin management settings: ${response.status}`,
    );
  }
  const data = (await response.json()) as {
    domain_agent_mappings: PluginDomainAgentMappingDto[];
  };
  const mapped = fromPluginManagementDto(data);
  writeYLog({
    optType: OptType.view,
    optDetail: "CM助手-全量-系统设置-插件管理查看",
    url: "/api/system-settings/plugin-management",
    returnParam: mapped,
  });
  return mapped;
}

export async function updatePluginManagementSettings(
  body: PluginManagementUpdate,
): Promise<PluginManagementSettings> {
  const payload = toPluginManagementDto(body);
  const response = await apiFetch(
    `${getBackendBaseURL()}/api/system-settings/plugin-management`,
    {
      method: "PUT",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify(payload),
    },
  );
  if (!response.ok) {
    const detail = await response
      .json()
      .catch(() => ({ detail: "Failed to update plugin management settings" }));
    throw new Error(detail.detail ?? "Failed to update plugin management settings");
  }
  const data = (await response.json()) as {
    domain_agent_mappings: PluginDomainAgentMappingDto[];
  };
  const mapped = fromPluginManagementDto(data);
  writeYLog({
    optType: OptType.edit,
    optDetail: "CM助手-全量-系统设置-插件管理编辑",
    url: "/api/system-settings/plugin-management",
    reqParam: payload,
    returnParam: mapped,
  });
  return mapped;
}

export async function loadPromptPrefixSettings(): Promise<PromptPrefixSettings> {
  const response = await apiFetch(
    `${getBackendBaseURL()}/api/system-settings/prompt-prefix`,
  );
  if (!response.ok) {
    throw new Error(`Failed to load prompt prefix settings: ${response.status}`);
  }
  const data = (await response.json()) as PromptPrefixSettings;
  writeYLog({
    optType: OptType.view,
    optDetail: "CM助手-全量-系统设置-提示词前缀查看",
    url: "/api/system-settings/prompt-prefix",
    returnParam: data,
  });
  return data;
}

export async function updatePromptPrefixSettings(
  body: PromptPrefixUpdate,
): Promise<PromptPrefixSettings> {
  const response = await apiFetch(
    `${getBackendBaseURL()}/api/system-settings/prompt-prefix`,
    {
      method: "PUT",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify(body),
    },
  );
  if (!response.ok) {
    const detail = await response
      .json()
      .catch(() => ({ detail: "Failed to update prompt prefix" }));
    throw new Error(detail.detail ?? "Failed to update prompt prefix");
  }
  const data = (await response.json()) as PromptPrefixSettings;
  writeYLog({
    optType: OptType.edit,
    optDetail: "CM助手-全量-系统设置-提示词前缀编辑",
    url: "/api/system-settings/prompt-prefix",
    reqParam: body,
    returnParam: data,
  });
  return data;
}

export interface PrivateSquareStatus {
  enabled: boolean;
  password_set: boolean;
}

export interface PrivateSquareUpdate {
  enabled?: boolean;
  password?: string;
}

export interface CitationDisplaySettings {
  reference_mode_enabled: boolean;
  cleanup_words: string[];
}

export interface CitationDisplayUpdate {
  reference_mode_enabled?: boolean;
  cleanup_words?: string[];
}

export interface LeaderboardSettings {
  exclude_user_ids: string[];
  include_scheduled: boolean;
  include_admins: boolean;
  include_failed: boolean;
  cleanup_system_questions: boolean;
}

export interface LeaderboardSettingsUpdate {
  exclude_user_ids?: string[];
  include_scheduled?: boolean;
  include_admins?: boolean;
  include_failed?: boolean;
  cleanup_system_questions?: boolean;
}

export async function loadPrivateSquareStatus(): Promise<PrivateSquareStatus> {
  const response = await apiFetch(
    `${getBackendBaseURL()}/api/system-settings/private-square`,
  );
  if (!response.ok) {
    throw new Error(
      `Failed to load private square settings: ${response.status}`,
    );
  }
  const data = (await response.json()) as PrivateSquareStatus;
  writeYLog({
    optType: OptType.view,
    optDetail: "CM助手-全量-系统设置-私密广场查看",
    url: "/api/system-settings/private-square",
    returnParam: data,
  });
  return data;
}

export interface PublishSquare {
  id: string;
  name: string;
  description: string;
}

export interface PublishSquaresSettings {
  squares: PublishSquare[];
  default_square_id: string;
}

export interface PublishSquaresUpdate {
  squares?: PublishSquare[];
  default_square_id?: string;
}

export async function loadPublishSquares(): Promise<PublishSquaresSettings> {
  const response = await apiFetch(
    `${getBackendBaseURL()}/api/system-settings/publish-squares`,
  );
  if (!response.ok) {
    throw new Error(`Failed to load publish squares: ${response.status}`);
  }
  const data = (await response.json()) as PublishSquaresSettings;
  writeYLog({
    optType: OptType.view,
    optDetail: "CM助手-全量-系统设置-发布广场查看",
    url: "/api/system-settings/publish-squares",
    returnParam: data,
  });
  return data;
}

export async function updatePublishSquares(
  body: PublishSquaresUpdate,
): Promise<PublishSquaresSettings> {
  const response = await apiFetch(
    `${getBackendBaseURL()}/api/system-settings/publish-squares`,
    {
      method: "PUT",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify(body),
    },
  );
  if (!response.ok) {
    const detail = await response
      .json()
      .catch(() => ({ detail: "Failed to update publish squares" }));
    throw new Error(detail.detail ?? "Failed to update publish squares");
  }
  const data = (await response.json()) as PublishSquaresSettings;
  writeYLog({
    optType: OptType.edit,
    optDetail: "CM助手-全量-系统设置-发布广场编辑",
    url: "/api/system-settings/publish-squares",
    reqParam: body,
    returnParam: data,
  });
  return data;
}

export const BUILTIN_THEME_IDS = [
  "light",
  "dark",
  "lightblue",
  "lightgreen",
  "iceblue",
  "lightyellow",
] as const;

export type BuiltinThemeId = (typeof BUILTIN_THEME_IDS)[number];
export type ThemeMode = BuiltinThemeId | `custom-theme-${string}`;
export type CustomThemeBaseMode = "light" | "dark";

export interface CustomThemeColorOverrides {
  button_hover?: string | null;
  navigation_gradient_start?: string | null;
  navigation_gradient_end?: string | null;
  selected_background?: string | null;
  border?: string | null;
  muted?: string | null;
  muted_text?: string | null;
  destructive?: string | null;
  brand_title?: string | null;
  primary_foreground?: string | null;
}

export interface CustomThemePreset {
  id: `custom-theme-${string}`;
  name: string;
  primary: string;
  text_color?: string | null;
  mode: CustomThemeBaseMode;
  overrides?: CustomThemeColorOverrides;
  enabled: boolean;
  sort_order: number;
}
export type ViewMode = "card" | "list";
export type LayoutMode = "full" | "compact";
export type CompactShortcutParamType = "login" | "theme" | "path";

export interface CompactShortcutRouteParam {
  key: string;
  paramType: CompactShortcutParamType;
  source?: string | null;
  customValue?: string | null;
  themeValue?: string | null;
}

export interface CompactShortcutButton {
  id: string;
  label: string;
  url: string;
  route_params: CompactShortcutRouteParam[];
  enabled: boolean;
  sort_order: number;
}

export interface AppearanceSettings {
  default_theme: ThemeMode;
  default_skill_view: ViewMode;
  default_agent_view: ViewMode;
  default_layout_mode: LayoutMode;
  compact_shortcut_buttons: CompactShortcutButton[];
  custom_themes: CustomThemePreset[];
}

export interface AppearanceUpdate {
  default_theme?: ThemeMode;
  default_skill_view?: ViewMode;
  default_agent_view?: ViewMode;
  default_layout_mode?: LayoutMode;
  compact_shortcut_buttons?: CompactShortcutButton[];
  custom_themes?: CustomThemePreset[];
}

export async function loadAppearanceSettings(): Promise<AppearanceSettings> {
  const response = await apiFetch(
    `${getBackendBaseURL()}/api/system-settings/appearance`,
  );
  if (!response.ok) {
    throw new Error(
      `Failed to load appearance settings: ${response.status}`,
    );
  }
  const data = (await response.json()) as AppearanceSettings;
  writeYLog({
    optType: OptType.view,
    optDetail: "CM助手-全量-系统设置-外观查看",
    url: "/api/system-settings/appearance",
    returnParam: data,
  });
  return data;
}

export async function updateAppearanceSettings(
  body: AppearanceUpdate,
): Promise<AppearanceSettings> {
  const response = await apiFetch(
    `${getBackendBaseURL()}/api/system-settings/appearance`,
    {
      method: "PUT",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify(body),
    },
  );
  if (!response.ok) {
    const detail = await response
      .json()
      .catch(() => ({ detail: "Failed to update appearance" }));
    throw new Error(detail.detail ?? "Failed to update appearance");
  }
  const data = (await response.json()) as AppearanceSettings;
  writeYLog({
    optType: OptType.edit,
    optDetail: "CM助手-全量-系统设置-外观编辑",
    url: "/api/system-settings/appearance",
    reqParam: body,
    returnParam: data,
  });
  return data;
}

export async function loadCitationDisplaySettings(): Promise<CitationDisplaySettings> {
  const response = await apiFetch(
    `${getBackendBaseURL()}/api/system-settings/citation-display`,
  );
  if (!response.ok) {
    throw new Error(
      `Failed to load citation display settings: ${response.status}`,
    );
  }
  const data = (await response.json()) as CitationDisplaySettings;
  writeYLog({
    optType: OptType.view,
    optDetail: "CM助手-全量-系统设置-引用展示查看",
    url: "/api/system-settings/citation-display",
    returnParam: data,
  });
  return data;
}

export async function loadLeaderboardSettings(): Promise<LeaderboardSettings> {
  const response = await apiFetch(
    `${getBackendBaseURL()}/api/system-settings/leaderboard`,
  );
  if (!response.ok) {
    throw new Error(`Failed to load leaderboard settings: ${response.status}`);
  }
  const data = (await response.json()) as LeaderboardSettings;
  writeYLog({
    optType: OptType.view,
    optDetail: "CM助手-全量-系统设置-排行榜查看",
    url: "/api/system-settings/leaderboard",
    returnParam: data,
  });
  return data;
}

export async function updateLeaderboardSettings(
  body: LeaderboardSettingsUpdate,
): Promise<LeaderboardSettings> {
  const response = await apiFetch(
    `${getBackendBaseURL()}/api/system-settings/leaderboard`,
    {
      method: "PUT",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify(body),
    },
  );
  if (!response.ok) {
    const detail = await response
      .json()
      .catch(() => ({ detail: "Failed to update leaderboard settings" }));
    throw new Error(detail.detail ?? "Failed to update leaderboard settings");
  }
  const data = (await response.json()) as LeaderboardSettings;
  writeYLog({
    optType: OptType.edit,
    optDetail: "CM助手-全量-系统设置-排行榜编辑",
    url: "/api/system-settings/leaderboard",
    reqParam: body,
    returnParam: data,
  });
  return data;
}

export async function updateCitationDisplaySettings(
  body: CitationDisplayUpdate,
): Promise<CitationDisplaySettings> {
  const response = await apiFetch(
    `${getBackendBaseURL()}/api/system-settings/citation-display`,
    {
      method: "PUT",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify(body),
    },
  );
  if (!response.ok) {
    const detail = await response
      .json()
      .catch(() => ({ detail: "Failed to update citation display" }));
    throw new Error(detail.detail ?? "Failed to update citation display");
  }
  const data = (await response.json()) as CitationDisplaySettings;
  writeYLog({
    optType: OptType.edit,
    optDetail: "CM助手-全量-系统设置-引用展示编辑",
    url: "/api/system-settings/citation-display",
    reqParam: body,
    returnParam: data,
  });
  return data;
}

export interface SkillCompressionSettings {
  enabled: boolean;
  search_top_n: number;
  keep_index_in_prompt: boolean;
}

export interface SkillCompressionUpdate {
  enabled?: boolean;
  search_top_n?: number;
  keep_index_in_prompt?: boolean;
}

export interface ModelConcurrencySettings {
  enabled: boolean;
  default_limit: number;
  model_limits: Record<string, number>;
  user_default_limit: number;
  user_model_limits: Record<string, number>;
}

export interface ModelConcurrencyUpdate {
  enabled?: boolean;
  default_limit?: number;
  model_limits?: Record<string, number>;
  user_default_limit?: number;
  user_model_limits?: Record<string, number>;
}

export async function loadSkillCompressionSettings(): Promise<SkillCompressionSettings> {
  const response = await apiFetch(
    `${getBackendBaseURL()}/api/system-settings/skill-compression`,
  );
  if (!response.ok) {
    throw new Error(
      `Failed to load skill compression settings: ${response.status}`,
    );
  }
  const data = (await response.json()) as SkillCompressionSettings;
  writeYLog({
    optType: OptType.view,
    optDetail: "CM助手-全量-系统设置-技能压缩查看",
    url: "/api/system-settings/skill-compression",
    returnParam: data,
  });
  return data;
}

export async function loadModelConcurrencySettings(): Promise<ModelConcurrencySettings> {
  const response = await apiFetch(
    `${getBackendBaseURL()}/api/system-settings/model-concurrency`,
  );
  if (!response.ok) {
    throw new Error(
      `Failed to load model concurrency settings: ${response.status}`,
    );
  }
  const data = (await response.json()) as ModelConcurrencySettings;
  writeYLog({
    optType: OptType.view,
    optDetail: "CM助手-全量-系统设置-模型并发限制查看",
    url: "/api/system-settings/model-concurrency",
    returnParam: data,
  });
  return data;
}

export async function updateModelConcurrencySettings(
  body: ModelConcurrencyUpdate,
): Promise<ModelConcurrencySettings> {
  const response = await apiFetch(
    `${getBackendBaseURL()}/api/system-settings/model-concurrency`,
    {
      method: "PUT",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify(body),
    },
  );
  if (!response.ok) {
    const detail = await response
      .json()
      .catch(() => ({ detail: "Failed to update model concurrency settings" }));
    throw new Error(detail.detail ?? "Failed to update model concurrency settings");
  }
  const data = (await response.json()) as ModelConcurrencySettings;
  writeYLog({
    optType: OptType.edit,
    optDetail: "CM助手-全量-系统设置-模型并发限制编辑",
    url: "/api/system-settings/model-concurrency",
    reqParam: body,
    returnParam: data,
  });
  return data;
}

export async function updateSkillCompressionSettings(
  body: SkillCompressionUpdate,
): Promise<SkillCompressionSettings> {
  const response = await apiFetch(
    `${getBackendBaseURL()}/api/system-settings/skill-compression`,
    {
      method: "PUT",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify(body),
    },
  );
  if (!response.ok) {
    const detail = await response
      .json()
      .catch(() => ({ detail: "Failed to update skill compression" }));
    throw new Error(detail.detail ?? "Failed to update skill compression");
  }
  const data = (await response.json()) as SkillCompressionSettings;
  writeYLog({
    optType: OptType.edit,
    optDetail: "CM助手-全量-系统设置-技能压缩编辑",
    url: "/api/system-settings/skill-compression",
    reqParam: body,
    returnParam: data,
  });
  return data;
}

/** 「按类型聚合」模块（zzJC / zzXD）选中的智能体标签配置（需求 0616 #3/#4）。 */
export interface AgentModuleConfig {
  key: string;
  tag_ids: string[];
}

export async function loadAgentModuleConfig(
  key: string,
): Promise<AgentModuleConfig> {
  const response = await apiFetch(
    `${getBackendBaseURL()}/api/system-settings/agent-modules/${encodeURIComponent(key)}`,
  );
  if (!response.ok) {
    throw new Error(`Failed to load agent module config: ${response.status}`);
  }
  const data = (await response.json()) as AgentModuleConfig;
  writeYLog({
    optType: OptType.view,
    optDetail: "CM助手-全量-系统设置-智能体模块查看",
    url: `/api/system-settings/agent-modules/${key}`,
    reqParam: { key },
    returnParam: data,
  });
  return data;
}

export async function updateAgentModuleConfig(
  key: string,
  tagIds: string[],
): Promise<AgentModuleConfig> {
  const response = await apiFetch(
    `${getBackendBaseURL()}/api/system-settings/agent-modules/${encodeURIComponent(key)}`,
    {
      method: "PUT",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify({ tag_ids: tagIds }),
    },
  );
  if (!response.ok) {
    const detail = await response
      .json()
      .catch(() => ({ detail: "Failed to update agent module config" }));
    throw new Error(detail.detail ?? "Failed to update agent module config");
  }
  const data = (await response.json()) as AgentModuleConfig;
  writeYLog({
    optType: OptType.edit,
    optDetail: "CM助手-全量-系统设置-智能体模块编辑",
    url: `/api/system-settings/agent-modules/${key}`,
    reqParam: { key, tag_ids: tagIds },
    returnParam: data,
  });
  return data;
}

export interface LogSystemSettings {
  enabled: boolean;
  url: string;
  label: string;
}

export async function loadLogSystemSettings(): Promise<LogSystemSettings> {
  const response = await apiFetch(
    `${getBackendBaseURL()}/api/system-settings/log-system`,
  );
  if (!response.ok) {
    throw new Error(`Failed to load log system settings: ${response.status}`);
  }
  const data = (await response.json()) as LogSystemSettings;
  writeYLog({
    optType: OptType.view,
    optDetail: "CM助手-全量-系统设置-日志系统查看",
    url: "/api/system-settings/log-system",
    returnParam: data,
  });
  return data;
}

export async function updatePrivateSquareSettings(
  body: PrivateSquareUpdate,
): Promise<PrivateSquareStatus> {
  const response = await apiFetch(
    `${getBackendBaseURL()}/api/system-settings/private-square`,
    {
      method: "PUT",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify(body),
    },
  );
  if (!response.ok) {
    const detail = await response
      .json()
      .catch(() => ({ detail: "Failed to update private square" }));
    throw new Error(detail.detail ?? "Failed to update private square");
  }
  const data = (await response.json()) as PrivateSquareStatus;
  writeYLog({
    optType: OptType.edit,
    optDetail: "CM助手-全量-系统设置-私密广场编辑",
    url: "/api/system-settings/private-square",
    // omit `password` (secret) from the logged request params
    reqParam: { enabled: body.enabled, password_set: body.password != null },
    returnParam: data,
  });
  return data;
}