Upload 2 files

app/store/config.ts

@@ -0,0 +1,325 @@
+import { LLMModel } from "../client/api";
+import { DalleSize, DalleQuality, DalleStyle } from "../typing";
+import { getClientConfig } from "../config/client";
+import {
+  DEFAULT_INPUT_TEMPLATE,
+  DEFAULT_MODELS,
+  DEFAULT_SIDEBAR_WIDTH,
+  DEFAULT_TTS_ENGINE,
+  DEFAULT_TTS_ENGINES,
+  DEFAULT_TTS_MODEL,
+  DEFAULT_TTS_MODELS,
+  DEFAULT_TTS_VOICE,
+  DEFAULT_TTS_VOICES,
+  StoreKey,
+  ServiceProvider,
+} from "../constant";
+import { createPersistStore } from "../utils/store";
+import type { Voice } from "rt-client";
+
+export type ModelType = (typeof DEFAULT_MODELS)[number]["name"];
+export type TTSModelType = (typeof DEFAULT_TTS_MODELS)[number];
+export type TTSVoiceType = (typeof DEFAULT_TTS_VOICES)[number];
+export type TTSEngineType = (typeof DEFAULT_TTS_ENGINES)[number];
+
+export enum SubmitKey {
+  Enter = "Enter",
+  CtrlEnter = "Ctrl + Enter",
+  ShiftEnter = "Shift + Enter",
+  AltEnter = "Alt + Enter",
+  MetaEnter = "Meta + Enter",
+}
+
+export enum Theme {
+  Auto = "auto",
+  Dark = "dark",
+  Light = "light",
+}
+
+const config = getClientConfig();
+
+export type ModelConfig = {
+  model: ModelType;
+  providerName: ServiceProvider;
+  temperature: number;
+  top_p: number;
+  max_tokens: number;
+  presence_penalty: number;
+  frequency_penalty: number;
+  sendMemory: boolean;
+  historyMessageCount: number;
+  compressMessageLengthThreshold: number;
+  compressModel: string;
+  compressProviderName: string;
+  enableInjectSystemPrompts: boolean;
+  template: string;
+  size: DalleSize;
+  quality: DalleQuality;
+  style: DalleStyle;
+};
+
+export type AppConfig = {
+  lastUpdate: number;
+  submitKey: SubmitKey;
+  avatar: string;
+  fontSize: number;
+  fontFamily: string;
+  theme: Theme;
+  tightBorder: boolean;
+  sendPreviewBubble: boolean;
+  enableAutoGenerateTitle: boolean;
+  sidebarWidth: number;
+  enableArtifacts: boolean;
+  enableCodeFold: boolean;
+  disablePromptHint: boolean;
+  dontShowMaskSplashScreen: boolean;
+  hideBuiltinMasks: boolean;
+  customModels: string;
+  models: LLMModel[];
+  modelConfig: ModelConfig;
+  ttsConfig: TTSConfig;
+  realtimeConfig: RealtimeConfig;
+  enableModelSearch: boolean;
+  enableThemeChange: boolean;
+  enablePromptHints: boolean;
+  enableClearContext: boolean;
+  enablePlugins: boolean;
+  enableShortcuts: boolean;
+};
+
+export const DEFAULT_CONFIG: AppConfig = {
+  lastUpdate: Date.now(),
+  submitKey: SubmitKey.CtrlEnter,
+  avatar: "1f603",
+  fontSize: 12,
+  fontFamily: "",
+  theme: Theme.Auto,
+  tightBorder: !!config?.isApp,
+  sendPreviewBubble: true,
+  enableAutoGenerateTitle: true,
+  sidebarWidth: DEFAULT_SIDEBAR_WIDTH,
+  enableArtifacts: true,
+  enableCodeFold: true,
+  disablePromptHint: false,
+  dontShowMaskSplashScreen: true,
+  hideBuiltinMasks: false,
+  customModels: "",
+  models: DEFAULT_MODELS as any as LLMModel[],
+  modelConfig: {
+    model: "gpt-4o-mini" as ModelType,
+    providerName: "OpenAI" as ServiceProvider,
+    temperature: 1,
+    top_p: 0.9,
+    max_tokens: 14000,
+    presence_penalty: 0.2,
+    frequency_penalty: 0.2,
+    sendMemory: true,
+    historyMessageCount: 30,
+    compressMessageLengthThreshold: 42000,
+    compressModel: "",
+    compressProviderName: "",
+    enableInjectSystemPrompts: true,
+    template: config?.template ?? DEFAULT_INPUT_TEMPLATE,
+    size: "1024x1024" as DalleSize,
+    quality: "standard" as DalleQuality,
+    style: "vivid" as DalleStyle,
+  },
+  ttsConfig: {
+    enable: false,
+    autoplay: false,
+    engine: DEFAULT_TTS_ENGINE,
+    model: DEFAULT_TTS_MODEL,
+    voice: DEFAULT_TTS_VOICE,
+    speed: 1.0,
+  },
+  realtimeConfig: {
+    enable: false,
+    provider: "OpenAI" as ServiceProvider,
+    model: "gpt-4o-realtime-preview-2024-10-01",
+    apiKey: "",
+    azure: {
+      endpoint: "",
+      deployment: "",
+    },
+    temperature: 0.9,
+    voice: "alloy" as Voice,
+  },
+  enableModelSearch: false,
+  enableThemeChange: false,
+  enablePromptHints: false,
+  enableClearContext: true,
+  enablePlugins: false,
+  enableShortcuts: false,
+};
+
+export type ChatConfig = typeof DEFAULT_CONFIG;
+
+export type TTSConfig = {
+  enable: boolean;
+  autoplay: boolean;
+  engine: TTSEngineType;
+  model: TTSModelType;
+  voice: TTSVoiceType;
+  speed: number;
+};
+
+export type RealtimeConfig = {
+  enable: boolean;
+  provider: ServiceProvider;
+  model: string;
+  apiKey: string;
+  azure: {
+    endpoint: string;
+    deployment: string;
+  };
+  temperature: number;
+  voice: Voice;
+};
+
+export function limitNumber(
+  x: number,
+  min: number,
+  max: number,
+  defaultValue: number,
+) {
+  if (isNaN(x)) {
+    return defaultValue;
+  }
+
+  return Math.min(max, Math.max(min, x));
+}
+
+export const TTSConfigValidator = {
+  engine(x: string) {
+    return x as TTSEngineType;
+  },
+  model(x: string) {
+    return x as TTSModelType;
+  },
+  voice(x: string) {
+    return x as TTSVoiceType;
+  },
+  speed(x: number) {
+    return limitNumber(x, 0.25, 4.0, 1.0);
+  },
+};
+
+export const ModalConfigValidator = {
+  model(x: string) {
+    return x as ModelType;
+  },
+  max_tokens(x: number) {
+    return limitNumber(x, 0, 512000, 1024);
+  },
+  presence_penalty(x: number) {
+    return limitNumber(x, -2, 2, 0);
+  },
+  frequency_penalty(x: number) {
+    return limitNumber(x, -2, 2, 0);
+  },
+  temperature(x: number) {
+    return limitNumber(x, 0, 2, 1);
+  },
+  top_p(x: number) {
+    return limitNumber(x, 0, 1, 1);
+  },
+};
+
+export const useAppConfig = createPersistStore(
+  { ...DEFAULT_CONFIG },
+  (set, get) => ({
+    reset() {
+      set(() => ({ ...DEFAULT_CONFIG }));
+    },
+
+    mergeModels(newModels: LLMModel[]) {
+      if (!newModels || newModels.length === 0) {
+        return;
+      }
+
+      const oldModels = get().models;
+      const modelMap: Record<string, LLMModel> = {};
+
+      for (const model of oldModels) {
+        model.available = false;
+        modelMap[`${model.name}@${model?.provider?.id}`] = model;
+      }
+
+      for (const model of newModels) {
+        model.available = true;
+        modelMap[`${model.name}@${model?.provider?.id}`] = model;
+      }
+
+      set(() => ({
+        models: Object.values(modelMap),
+      }));
+    },
+
+    allModels() {},
+  }),
+  {
+    name: StoreKey.Config,
+    version: 4.1,
+
+    merge(persistedState, currentState) {
+      const state = persistedState as ChatConfig | undefined;
+      if (!state) return { ...currentState };
+      const models = currentState.models.slice();
+      state.models.forEach((pModel) => {
+        const idx = models.findIndex(
+          (v) => v.name === pModel.name && v.provider === pModel.provider,
+        );
+        if (idx !== -1) models[idx] = pModel;
+        else models.push(pModel);
+      });
+      return { ...currentState, ...state, models: models };
+    },
+
+    migrate(persistedState, version) {
+      const state = persistedState as ChatConfig;
+
+      if (version < 3.4) {
+        state.modelConfig.sendMemory = true;
+        state.modelConfig.historyMessageCount = 4;
+        state.modelConfig.compressMessageLengthThreshold = 1000;
+        state.modelConfig.frequency_penalty = 0;
+        state.modelConfig.top_p = 1;
+        state.modelConfig.template = DEFAULT_INPUT_TEMPLATE;
+        state.dontShowMaskSplashScreen = false;
+        state.hideBuiltinMasks = false;
+      }
+
+      if (version < 3.5) {
+        state.customModels = "claude,claude-100k";
+      }
+
+      if (version < 3.6) {
+        state.modelConfig.enableInjectSystemPrompts = true;
+      }
+
+      if (version < 3.7) {
+        state.enableAutoGenerateTitle = true;
+      }
+
+      if (version < 3.8) {
+        state.lastUpdate = Date.now();
+      }
+
+      if (version < 3.9) {
+        state.modelConfig.template =
+          state.modelConfig.template !== DEFAULT_INPUT_TEMPLATE
+            ? state.modelConfig.template
+            : config?.template ?? DEFAULT_INPUT_TEMPLATE;
+      }
+
+      if (version < 4.1) {
+        state.modelConfig.compressModel =
+          DEFAULT_CONFIG.modelConfig.compressModel;
+        state.modelConfig.compressProviderName =
+          DEFAULT_CONFIG.modelConfig.compressProviderName;
+      }
+
+      return state as any;
+    },
+  },
+);

app/utils.ts

@@ -0,0 +1,474 @@
+import { useEffect, useState } from "react";
+import { showToast } from "./components/ui-lib";
+import Locale from "./locales";
+import { RequestMessage } from "./client/api";
+// import { fetch as tauriFetch, ResponseType } from "@tauri-apps/api/http";
+import { fetch as tauriStreamFetch } from "./utils/stream";
+import { ServiceProvider } from "./constant";
+
+export function trimTopic(topic: string) {
+  // Fix an issue where double quotes still show in the Indonesian language
+  // This will remove the specified punctuation from the end of the string
+  // and also trim quotes from both the start and end if they exist.
+  return (
+    topic
+      // fix for gemini
+      .replace(/^["""*]+|["""*]+$/g, "")
+      .replace(/[，。！？""""、,.!?*]*$/, "")
+  );
+}
+
+export async function copyToClipboard(text: string) {
+  try {
+    if (window.__TAURI__) {
+      window.__TAURI__.writeText(text);
+    } else {
+      await navigator.clipboard.writeText(text);
+    }
+
+    showToast(Locale.Copy.Success);
+  } catch (error) {
+    const textArea = document.createElement("textarea");
+    textArea.value = text;
+    document.body.appendChild(textArea);
+    textArea.focus();
+    textArea.select();
+    try {
+      document.execCommand("copy");
+      showToast(Locale.Copy.Success);
+    } catch (error) {
+      showToast(Locale.Copy.Failed);
+    }
+    document.body.removeChild(textArea);
+  }
+}
+
+export async function downloadAs(text: string, filename: string) {
+  if (window.__TAURI__) {
+    const result = await window.__TAURI__.dialog.save({
+      defaultPath: `${filename}`,
+      filters: [
+        {
+          name: `${filename.split(".").pop()} files`,
+          extensions: [`${filename.split(".").pop()}`],
+        },
+        {
+          name: "All Files",
+          extensions: ["*"],
+        },
+      ],
+    });
+
+    if (result !== null) {
+      try {
+        await window.__TAURI__.fs.writeTextFile(result, text);
+        showToast(Locale.Download.Success);
+      } catch (error) {
+        showToast(Locale.Download.Failed);
+      }
+    } else {
+      showToast(Locale.Download.Failed);
+    }
+  } else {
+    const element = document.createElement("a");
+    element.setAttribute(
+      "href",
+      "data:text/plain;charset=utf-8," + encodeURIComponent(text),
+    );
+    element.setAttribute("download", filename);
+
+    element.style.display = "none";
+    document.body.appendChild(element);
+
+    element.click();
+
+    document.body.removeChild(element);
+  }
+}
+
+export function readFromFile() {
+  return new Promise<string>((res, rej) => {
+    const fileInput = document.createElement("input");
+    fileInput.type = "file";
+    fileInput.accept = "application/json";
+
+    fileInput.onchange = (event: any) => {
+      const file = event.target.files[0];
+      const fileReader = new FileReader();
+      fileReader.onload = (e: any) => {
+        res(e.target.result);
+      };
+      fileReader.onerror = (e) => rej(e);
+      fileReader.readAsText(file);
+    };
+
+    fileInput.click();
+  });
+}
+
+export function isIOS() {
+  const userAgent = navigator.userAgent.toLowerCase();
+  return /iphone|ipad|ipod/.test(userAgent);
+}
+
+export function useWindowSize() {
+  const [size, setSize] = useState({
+    width: window.innerWidth,
+    height: window.innerHeight,
+  });
+
+  useEffect(() => {
+    const onResize = () => {
+      setSize({
+        width: window.innerWidth,
+        height: window.innerHeight,
+      });
+    };
+
+    window.addEventListener("resize", onResize);
+
+    return () => {
+      window.removeEventListener("resize", onResize);
+    };
+  }, []);
+
+  return size;
+}
+
+export const MOBILE_MAX_WIDTH = 600;
+export function useMobileScreen() {
+  const { width } = useWindowSize();
+
+  return width <= MOBILE_MAX_WIDTH;
+}
+
+export function isFirefox() {
+  return (
+    typeof navigator !== "undefined" && /firefox/i.test(navigator.userAgent)
+  );
+}
+
+export function selectOrCopy(el: HTMLElement, content: string) {
+  const currentSelection = window.getSelection();
+
+  if (currentSelection?.type === "Range") {
+    return false;
+  }
+
+  copyToClipboard(content);
+
+  return true;
+}
+
+function getDomContentWidth(dom: HTMLElement) {
+  const style = window.getComputedStyle(dom);
+  const paddingWidth =
+    parseFloat(style.paddingLeft) + parseFloat(style.paddingRight);
+  const width = dom.clientWidth - paddingWidth;
+  return width;
+}
+
+function getOrCreateMeasureDom(id: string, init?: (dom: HTMLElement) => void) {
+  let dom = document.getElementById(id);
+
+  if (!dom) {
+    dom = document.createElement("span");
+    dom.style.position = "absolute";
+    dom.style.wordBreak = "break-word";
+    dom.style.fontSize = "14px";
+    dom.style.transform = "translateY(-200vh)";
+    dom.style.pointerEvents = "none";
+    dom.style.opacity = "0";
+    dom.id = id;
+    document.body.appendChild(dom);
+    init?.(dom);
+  }
+
+  return dom!;
+}
+
+export function autoGrowTextArea(dom: HTMLTextAreaElement) {
+  const measureDom = getOrCreateMeasureDom("__measure");
+  const singleLineDom = getOrCreateMeasureDom("__single_measure", (dom) => {
+    dom.innerText = "TEXT_FOR_MEASURE";
+  });
+
+  const width = getDomContentWidth(dom);
+  measureDom.style.width = width + "px";
+  measureDom.innerText = dom.value !== "" ? dom.value : "1";
+  measureDom.style.fontSize = dom.style.fontSize;
+  measureDom.style.fontFamily = dom.style.fontFamily;
+  const endWithEmptyLine = dom.value.endsWith("\n");
+  const height = parseFloat(window.getComputedStyle(measureDom).height);
+  const singleLineHeight = parseFloat(
+    window.getComputedStyle(singleLineDom).height,
+  );
+
+  const rows =
+    Math.round(height / singleLineHeight) + (endWithEmptyLine ? 1 : 0);
+
+  return rows;
+}
+
+export function getCSSVar(varName: string) {
+  return getComputedStyle(document.body).getPropertyValue(varName).trim();
+}
+
+/**
+ * Detects Macintosh
+ */
+export function isMacOS(): boolean {
+  if (typeof window !== "undefined") {
+    let userAgent = window.navigator.userAgent.toLocaleLowerCase();
+    const macintosh = /iphone|ipad|ipod|macintosh/.test(userAgent);
+    return !!macintosh;
+  }
+  return false;
+}
+
+export function getMessageTextContent(message: RequestMessage) {
+  if (typeof message.content === "string") {
+    return message.content;
+  }
+  for (const c of message.content) {
+    if (c.type === "text") {
+      return c.text ?? "";
+    }
+  }
+  return "";
+}
+
+export function getMessageTextContentWithoutThinking(message: RequestMessage) {
+  let content = "";
+  if (typeof message.content === "string") {
+    content = message.content;
+  } else {
+    for (const c of message.content) {
+      if (c.type === "text") {
+        content = c.text ?? "";
+        break;
+      }
+    }
+  }
+  // 匹配以 <think> 开头，至闭合 </think>之间的内容，如果没有闭合，则匹配到结尾
+  const pattern = /^<think>[\s\S]*?(<\/think>|$)/;
+  return content.replace(pattern, "").trim(); // 直接移除匹配的部分
+}
+
+export function getMessageImages(message: RequestMessage): string[] {
+  if (typeof message.content === "string") {
+    return [];
+  }
+  const urls: string[] = [];
+  for (const c of message.content) {
+    if (c.type === "image_url") {
+      urls.push(c.image_url?.url ?? "");
+    }
+  }
+  return urls;
+}
+
+export function isVisionModel(model: string) {
+  const modelLower = model.toLowerCase();
+  const excludeKeywords = ["claude-3-5-haiku-20241022"];
+  const visionKeywords = [
+    "vision",
+    "gemini",
+    "grok",
+    "gpt-4o",
+    "gpt-4.1",
+    "gpt-5",
+    "claude-3",
+    "learnlm",
+    "vl",
+    "QVQ-72B-Preview",
+  ];
+  const isGpt4Turbo =
+    modelLower.includes("gpt-4-turbo") && !modelLower.includes("preview");
+
+  return (
+    !excludeKeywords.some((keyword) =>
+      modelLower.includes(keyword.toLowerCase()),
+    ) &&
+    (visionKeywords.some((keyword) =>
+      modelLower.includes(keyword.toLowerCase()),
+    ) ||
+      isGpt4Turbo ||
+      isDalle3(modelLower))
+  );
+}
+
+export function isDalle3(model: string) {
+  return "dall-e-3" === model;
+}
+
+export function showPlugins(providerName?: string, model?: string) {
+  // 始终允许gemini-2.0-flash-exp使用插件（联网功能）
+  if (model === "gemini-2.0-flash-exp") {
+    return true;
+  }
+
+  // 恢复原来的功能，允许特定provider使用插件
+  if (!providerName || !model) return false;
+
+  const provider = providerName as ServiceProvider;
+
+  // 检查模型名称是否包含 deepseek-chat 或 deepseek-v3（不区分大小写）
+  if (
+    model.toLowerCase().includes("deepseek-chat") ||
+    model.toLowerCase().includes("deepseek-v3") ||
+    model.toLowerCase().includes("deepseek-r1") ||
+    model.toLowerCase().includes("deepseek-reasoner")
+  ) {
+    return true;
+  }
+
+  if (
+    provider === ServiceProvider.OpenAI ||
+    provider === ServiceProvider.Azure ||
+    provider === ServiceProvider.Moonshot ||
+    provider === ServiceProvider.ChatGLM
+  ) {
+    return true;
+  }
+
+  if (provider === ServiceProvider.Anthropic && !model.includes("claude-2")) {
+    return true;
+  }
+
+  if (provider === ServiceProvider.Google && !model.includes("vision")) {
+    return true;
+  }
+
+  return false;
+}
+
+export function fetch(
+  url: string,
+  options?: Record<string, unknown>,
+): Promise<any> {
+  if (window.__TAURI__) {
+    return tauriStreamFetch(url, options);
+  }
+  return window.fetch(url, options);
+}
+
+export function adapter(config: Record<string, unknown>) {
+  const { baseURL, url, params, data: body, ...rest } = config;
+  const path = baseURL ? `${baseURL}${url}` : url;
+  const fetchUrl = params
+    ? `${path}?${new URLSearchParams(params as any).toString()}`
+    : path;
+  return fetch(fetchUrl as string, { ...rest, body }).then((res) => {
+    const { status, headers, statusText } = res;
+    return res
+      .text()
+      .then((data: string) => ({ status, statusText, headers, data }));
+  });
+}
+
+export function safeLocalStorage(): {
+  getItem: (key: string) => string | null;
+  setItem: (key: string, value: string) => void;
+  removeItem: (key: string) => void;
+  clear: () => void;
+} {
+  let storage: Storage | null;
+
+  try {
+    if (typeof window !== "undefined" && window.localStorage) {
+      storage = window.localStorage;
+    } else {
+      storage = null;
+    }
+  } catch (e) {
+    console.error("localStorage is not available:", e);
+    storage = null;
+  }
+
+  return {
+    getItem(key: string): string | null {
+      if (storage) {
+        return storage.getItem(key);
+      } else {
+        console.warn(
+          `Attempted to get item "${key}" from localStorage, but localStorage is not available.`,
+        );
+        return null;
+      }
+    },
+    setItem(key: string, value: string): void {
+      if (storage) {
+        storage.setItem(key, value);
+      } else {
+        console.warn(
+          `Attempted to set item "${key}" in localStorage, but localStorage is not available.`,
+        );
+      }
+    },
+    removeItem(key: string): void {
+      if (storage) {
+        storage.removeItem(key);
+      } else {
+        console.warn(
+          `Attempted to remove item "${key}" from localStorage, but localStorage is not available.`,
+        );
+      }
+    },
+    clear(): void {
+      if (storage) {
+        storage.clear();
+      } else {
+        console.warn(
+          "Attempted to clear localStorage, but localStorage is not available.",
+        );
+      }
+    },
+  };
+}
+
+export function getOperationId(operation: {
+  operationId?: string;
+  method: string;
+  path: string;
+}) {
+  // pattern '^[a-zA-Z0-9_-]+$'
+  return (
+    operation?.operationId ||
+    `${operation.method.toUpperCase()}${operation.path.replaceAll("/", "_")}`
+  );
+}
+
+export function clientUpdate() {
+  // this a wild for updating client app
+  return window.__TAURI__?.updater
+    .checkUpdate()
+    .then((updateResult) => {
+      if (updateResult.shouldUpdate) {
+        window.__TAURI__?.updater
+          .installUpdate()
+          .then((result) => {
+            showToast(Locale.Settings.Update.Success);
+          })
+          .catch((e) => {
+            console.error("[Install Update Error]", e);
+            showToast(Locale.Settings.Update.Failed);
+          });
+      }
+    })
+    .catch((e) => {
+      console.error("[Check Update Error]", e);
+      showToast(Locale.Settings.Update.Failed);
+    });
+}
+
+// https://gist.github.com/iwill/a83038623ba4fef6abb9efca87ae9ccb
+export function semverCompare(a: string, b: string) {
+  if (a.startsWith(b + "-")) return -1;
+  if (b.startsWith(a + "-")) return 1;
+  return a.localeCompare(b, undefined, {
+    numeric: true,
+    sensitivity: "case",
+    caseFirst: "upper",
+  });
+}