@lobehub/lobehub 2.0.0-next.184 → 2.0.0-next.185

package/locales/zh-TW/auth.json

@@ -147,6 +147,7 @@
   "loginGuide.f4": "探索強大的外掛功能",
   "loginGuide.title": "登入後，您可以：",
   "loginOrSignup": "登入 / 註冊",
+  "profile.account": "帳戶",
   "profile.authorizations.actions.revoke": "取消授權",
   "profile.authorizations.revoke.description": "取消授權後，該工具將無法存取您的資料。如需再次使用，需重新授權。",
   "profile.authorizations.revoke.title": "確認取消授權 {{name}}？",

package/locales/zh-TW/models.json

@@ -223,7 +223,30 @@
   "alibaba/qwen-3-235b.description": "Qwen3 是 Qwen 系列的最新一代，提供完整的密集與 MoE 模型組合。透過大規模訓練，在推理、指令遵循、代理能力與多語言支援方面實現突破。",
   "alibaba/qwen-3-30b.description": "Qwen3 是 Qwen 系列的最新一代，提供完整的密集與 MoE 模型組合。透過大規模訓練，在推理、指令遵循、代理能力與多語言支援方面實現突破。",
   "alibaba/qwen-3-32b.description": "Qwen3 是 Qwen 系列的最新一代，提供完整的密集與 MoE 模型組合。透過大規模訓練，在推理、指令遵循、代理能力與多語言支援方面實現突破。",
+  "alibaba/qwen3-coder.description": "Qwen3-Coder-480B-A35B-Instruct 是 Qwen 最具代理能力的程式模型，在代理式編碼、瀏覽器操作及其他核心編碼任務上表現優異，達到與 Claude Sonnet 同級的成果。",
+  "amazon/nova-lite.description": "一款極低成本的多模態模型，能以極快速度處理圖像、影片與文字輸入。",
+  "amazon/nova-micro.description": "一款僅支援文字的模型，提供超低延遲與極低成本的運算效能。",
+  "amazon/nova-pro.description": "一款功能強大的多模態模型，在準確性、速度與成本之間達到最佳平衡，適用於各類任務。",
   "amazon/titan-embed-text-v2.description": "Amazon Titan Text Embeddings V2 是一個輕量級、高效的多語言嵌入模型，支援 1024、512 和 256 維度。",
+  "anthropic.claude-3-5-sonnet-20240620-v1:0.description": "Claude 3.5 Sonnet 提升了業界標準，在多項評估中超越競爭對手與 Claude 3 Opus，同時維持中階速度與成本。",
+  "anthropic.claude-3-5-sonnet-20241022-v2:0.description": "Claude 3.5 Sonnet 提升了業界標準，在多項評估中超越競爭對手與 Claude 3 Opus，同時維持中階速度與成本。",
+  "anthropic.claude-3-haiku-20240307-v1:0.description": "Claude 3 Haiku 是 Anthropic 速度最快、體積最小的模型，能即時回應簡單查詢，提供流暢自然的 AI 體驗，並支援圖像輸入與 200K 的上下文視窗。",
+  "anthropic.claude-3-opus-20240229-v1:0.description": "Claude 3 Opus 是 Anthropic 最強大的 AI 模型，在處理高度複雜任務時展現最先進的效能，具備開放式提示與新穎情境的流暢應對能力，並支援圖像輸入與 200K 的上下文視窗。",
+  "anthropic.claude-3-sonnet-20240229-v1:0.description": "Claude 3 Sonnet 在智慧與速度之間取得平衡，適用於企業級工作負載，提供高性價比與可靠的大規模部署能力，並支援圖像輸入與 200K 的上下文視窗。",
+  "anthropic.claude-instant-v1.description": "一款快速、經濟且功能強大的模型，適用於日常對話、文字分析、摘要與文件問答。",
+  "anthropic.claude-v2.description": "一款功能全面的模型，涵蓋複雜對話、創意生成與精確指令執行等任務。",
+  "anthropic.claude-v2:1.description": "Claude 2 的升級版，具備雙倍上下文視窗，並在長文件與檢索增強生成（RAG）任務中提升可靠性、降低幻覺率與提升基於證據的準確性。",
+  "anthropic/claude-3-haiku.description": "Claude 3 Haiku 是 Anthropic 速度最快的模型，專為處理長提示的企業級工作負載設計，能快速分析大型文件如季報、合約或法律案件，成本僅為同類模型的一半。",
+  "anthropic/claude-3-opus.description": "Claude 3 Opus 是 Anthropic 最智慧的模型，在處理高度複雜任務時展現市場領先的效能，能流暢應對開放式提示與新穎情境，具備類人理解能力。",
+  "anthropic/claude-3.5-haiku.description": "Claude 3.5 Haiku 提升了速度、程式碼準確性與工具使用能力，適用於對速度與工具互動有高要求的場景。",
+  "anthropic/claude-3.5-sonnet.description": "Claude 3.5 Sonnet 是 Sonnet 系列中快速且高效的模型，具備更佳的程式與推理能力，部分版本已逐步由 Sonnet 3.7 或更新版本取代。",
+  "anthropic/claude-3.7-sonnet.description": "Claude 3.7 Sonnet 是升級版的 Sonnet 模型，具備更強的推理與程式能力，適用於企業級複雜任務。",
+  "anthropic/claude-haiku-4.5.description": "Claude Haiku 4.5 是 Anthropic 的高效能快速模型，在保持高準確度的同時提供極低延遲。",
+  "anthropic/claude-opus-4.1.description": "Opus 4.1 是 Anthropic 的高階模型，針對程式設計、複雜推理與長時間任務進行最佳化。",
+  "anthropic/claude-opus-4.5.description": "Claude Opus 4.5 是 Anthropic 的旗艦模型，結合頂尖智慧與可擴展效能，適用於複雜且高品質的推理任務。",
+  "anthropic/claude-opus-4.description": "Opus 4 是 Anthropic 為複雜任務與企業應用設計的旗艦模型。",
+  "anthropic/claude-sonnet-4.5.description": "Claude Sonnet 4.5 是 Anthropic 最新的混合推理模型，針對複雜推理與程式設計進行最佳化。",
+  "anthropic/claude-sonnet-4.description": "Claude Sonnet 4 是 Anthropic 的混合推理模型，具備思考與非思考能力的結合。",
   "gemini-flash-latest.description": "Gemini Flash 最新版本",
   "gemini-flash-lite-latest.description": "Gemini Flash-Lite 最新版本",
   "gemini-pro-latest.description": "Gemini Pro 最新版本",

package/locales/zh-TW/setting.json

@@ -215,6 +215,7 @@
   "settingAgent.name.placeholder": "請輸入助手名稱",
   "settingAgent.name.title": "名稱",
   "settingAgent.prompt.placeholder": "輸入助手設定，按 / 開啟指令選單",
+  "settingAgent.prompt.templatePlaceholder": "#### 目標\n描述此代理的主要目的與目標。\n\n#### 技能\n- 列出主要能力\n- 以及專業知識領域\n\n#### 工作流程\n1. 步驟式流程\n2. 代理執行任務的方式\n3. 與使用者的預期互動方式\n\n#### 限制\n- 必須遵守的重要限制\n- 行為準則",
   "settingAgent.prompt.title": "助手設定",
   "settingAgent.submit": "更新助手資訊",
   "settingAgent.tag.desc": "助手標籤將會在助手社群中顯示",

package/locales/zh-TW/subscription.json

@@ -271,15 +271,28 @@
   "referral.edit.hint": "支援 2-8 位英文字母、數字或底線",
   "referral.edit.placeholder": "輸入推薦碼",
   "referral.edit.save": "儲存",
+  "referral.errors.alreadyBound": "您已綁定邀請碼",
+  "referral.errors.backfillExpired": "補填期限已過。註冊後超過 3 天無法補填",
   "referral.errors.codeExists": "此推薦碼已被使用，請選擇其他碼",
+  "referral.errors.invalidCode": "邀請碼不存在，請確認後再試一次",
   "referral.errors.invalidFormat": "推薦碼格式錯誤，請輸入 2-8 位英文字母、數字或底線",
+  "referral.errors.selfReferral": "您不能使用自己的邀請碼",
   "referral.errors.updateFailed": "更新失敗，請稍後再試",
   "referral.inviteCode.description": "分享您的專屬推薦碼，邀請朋友註冊",
   "referral.inviteCode.title": "我的推薦碼",
   "referral.inviteLink.description": "複製連結並分享給朋友，完成註冊即可獲得獎勵",
   "referral.inviteLink.title": "推薦連結",
+  "referral.rules.backfill.alreadyBound": "您已綁定邀請碼",
+  "referral.rules.backfill.description": "忘記輸入邀請碼？您可以在註冊後 3 天內補填",
+  "referral.rules.backfill.expiredTip": "補填期限已過。註冊後超過 3 天無法補填",
+  "referral.rules.backfill.link": "補填邀請碼",
+  "referral.rules.backfill.placeholder": "請輸入邀請碼",
+  "referral.rules.backfill.submit": "確認綁定",
+  "referral.rules.backfill.success": "邀請碼綁定成功",
+  "referral.rules.backfill.title": "補填邀請碼",
   "referral.rules.description": "了解推薦獎勵計畫規則",
   "referral.rules.expiry": "點數有效期：用戶 100 天未活躍後，推薦點數將被清除",
+  "referral.rules.missedCode": "錯過邀請碼：您可以在註冊後 3 天內<0>補填</0>",
   "referral.rules.priority": "點數使用優先順序：免費點數 → 訂閱點數 → 推薦點數 → 儲值點數",
   "referral.rules.registration": "註冊方式：受邀者透過推薦連結註冊或在註冊頁輸入推薦碼",
   "referral.rules.reward": "獎勵：推薦人與受邀人各獲得 {{reward}}M 點數",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lobehub/lobehub",
-  "version": "2.0.0-next.184",
+  "version": "2.0.0-next.185",
   "description": "LobeHub - an open-source,comprehensive AI Agent framework that supports speech synthesis, multimodal, and extensible Function Call plugin system. Supports one-click free deployment of your private ChatGPT/LLM web application.",
   "keywords": [
     "framework",

package/src/store/image/utils/size.test.ts

@@ -0,0 +1,245 @@
+import { describe, expect, it } from 'vitest';
+
+import { adaptSizeToRatio, parseRatio } from './size';
+
+describe('size utils', () => {
+  describe('parseRatio', () => {
+    it('should parse valid ratio string correctly', () => {
+      expect(parseRatio('16:9')).toBe(16 / 9);
+      expect(parseRatio('4:3')).toBe(4 / 3);
+      expect(parseRatio('1:1')).toBe(1);
+      expect(parseRatio('21:9')).toBe(21 / 9);
+    });
+
+    it('should handle square ratio correctly', () => {
+      expect(parseRatio('1:1')).toBe(1);
+      expect(parseRatio('100:100')).toBe(1);
+      expect(parseRatio('512:512')).toBe(1);
+    });
+
+    it('should handle wide ratios correctly', () => {
+      expect(parseRatio('16:9')).toBeCloseTo(16 / 9, 6);
+      expect(parseRatio('2:1')).toBe(2);
+      expect(parseRatio('3:1')).toBe(3);
+    });
+
+    it('should handle tall ratios correctly', () => {
+      expect(parseRatio('9:16')).toBeCloseTo(0.5625, 4);
+      expect(parseRatio('1:2')).toBe(0.5);
+      expect(parseRatio('3:4')).toBe(0.75);
+    });
+
+    it('should handle decimal values in ratio string', () => {
+      expect(parseRatio('1.5:1')).toBe(1.5);
+      expect(parseRatio('16.5:9.5')).toBeCloseTo(16.5 / 9.5, 6);
+    });
+
+    it('should return 1 for invalid ratio string formats', () => {
+      expect(parseRatio('16')).toBe(1); // Missing colon
+      expect(parseRatio('16-9')).toBe(1); // Wrong separator
+      expect(parseRatio('16:9:1')).toBe(1); // Too many parts
+      expect(parseRatio('')).toBe(1); // Empty string
+      expect(parseRatio(':')).toBe(1); // Only separator
+    });
+
+    it('should return 1 for invalid input types', () => {
+      // @ts-expect-error - testing runtime behavior with invalid types
+      expect(parseRatio(null)).toBe(1);
+      // @ts-expect-error - testing runtime behavior with invalid types
+      expect(parseRatio(undefined)).toBe(1);
+      // @ts-expect-error - testing runtime behavior with invalid types
+      expect(parseRatio(123)).toBe(1);
+      // @ts-expect-error - testing runtime behavior with invalid types
+      expect(parseRatio({})).toBe(1);
+    });
+
+    it('should return 1 for non-numeric ratio parts', () => {
+      expect(parseRatio('abc:def')).toBe(1);
+      expect(parseRatio('16:abc')).toBe(1);
+      expect(parseRatio('abc:9')).toBe(1);
+      expect(parseRatio('NaN:9')).toBe(1);
+      expect(parseRatio('16:NaN')).toBe(1);
+    });
+
+    it('should return 1 for zero or negative values', () => {
+      expect(parseRatio('0:9')).toBe(1);
+      expect(parseRatio('16:0')).toBe(1);
+      expect(parseRatio('0:0')).toBe(1);
+      expect(parseRatio('-16:9')).toBe(1);
+      expect(parseRatio('16:-9')).toBe(1);
+      expect(parseRatio('-16:-9')).toBe(1);
+    });
+
+    it('should return 1 for Infinity values', () => {
+      expect(parseRatio('Infinity:9')).toBe(1);
+      expect(parseRatio('16:Infinity')).toBe(1);
+      expect(parseRatio('Infinity:Infinity')).toBe(1);
+    });
+  });
+
+  describe('adaptSizeToRatio', () => {
+    describe('valid inputs', () => {
+      it('should keep width and adjust height when target ratio is wider', () => {
+        // 16:9 (1.777) is wider than 4:3 (1.333)
+        const result = adaptSizeToRatio(16 / 9, 800, 600);
+        expect(result).toEqual({ width: 800, height: 450 });
+      });
+
+      it('should keep height and adjust width when target ratio is taller', () => {
+        // 4:3 (1.333) is taller than 16:9 (1.777)
+        const result = adaptSizeToRatio(4 / 3, 800, 450);
+        expect(result).toEqual({ width: 600, height: 450 });
+      });
+
+      it('should maintain dimensions when ratio matches current ratio', () => {
+        // 16:9 matches 1920:1080
+        const result = adaptSizeToRatio(16 / 9, 1920, 1080);
+        expect(result).toEqual({ width: 1920, height: 1080 });
+      });
+
+      it('should handle square ratio (1:1) correctly', () => {
+        // Current ratio: 800/600 = 1.333, target ratio: 1
+        // Since 1 < 1.333, keeps height (600), adjusts width to 600
+        const result = adaptSizeToRatio(1, 800, 600);
+        expect(result).toEqual({ width: 600, height: 600 });
+
+        // Current ratio: 600/800 = 0.75, target ratio: 1
+        // Since 1 > 0.75, keeps width (600), adjusts height to 600
+        const result2 = adaptSizeToRatio(1, 600, 800);
+        expect(result2).toEqual({ width: 600, height: 600 });
+      });
+
+      it('should round dimensions to nearest integer', () => {
+        // Current ratio: 1000/800 = 1.25, target ratio: 1.5
+        // Since 1.5 > 1.25, keeps width (1000), adjusts height to 1000/1.5 = 666.67 -> 667
+        const result = adaptSizeToRatio(1.5, 1000, 800);
+        expect(result.width).toBe(1000);
+        expect(result.height).toBe(667);
+        expect(Number.isInteger(result.width)).toBe(true);
+        expect(Number.isInteger(result.height)).toBe(true);
+      });
+
+      it('should handle very wide ratios correctly', () => {
+        const result = adaptSizeToRatio(3, 1200, 800);
+        expect(result).toEqual({ width: 1200, height: 400 });
+      });
+
+      it('should handle very tall ratios correctly', () => {
+        const result = adaptSizeToRatio(1 / 3, 1200, 800);
+        expect(result).toEqual({ width: 267, height: 800 });
+      });
+
+      it('should handle small dimensions', () => {
+        const result = adaptSizeToRatio(16 / 9, 320, 240);
+        expect(result).toEqual({ width: 320, height: 180 });
+      });
+
+      it('should handle large dimensions', () => {
+        const result = adaptSizeToRatio(16 / 9, 3840, 2880);
+        expect(result).toEqual({ width: 3840, height: 2160 });
+      });
+
+      it('should handle decimal ratio values', () => {
+        const result = adaptSizeToRatio(1.5, 900, 600);
+        expect(result).toEqual({ width: 900, height: 600 });
+      });
+    });
+
+    describe('error handling - invalid ratio', () => {
+      it('should throw error for zero ratio', () => {
+        expect(() => adaptSizeToRatio(0, 800, 600)).toThrow(
+          'Invalid ratio: must be a positive finite number',
+        );
+      });
+
+      it('should throw error for negative ratio', () => {
+        expect(() => adaptSizeToRatio(-1.5, 800, 600)).toThrow(
+          'Invalid ratio: must be a positive finite number',
+        );
+      });
+
+      it('should throw error for NaN ratio', () => {
+        expect(() => adaptSizeToRatio(NaN, 800, 600)).toThrow(
+          'Invalid ratio: must be a positive finite number',
+        );
+      });
+
+      it('should throw error for Infinity ratio', () => {
+        expect(() => adaptSizeToRatio(Infinity, 800, 600)).toThrow(
+          'Invalid ratio: must be a positive finite number',
+        );
+        expect(() => adaptSizeToRatio(-Infinity, 800, 600)).toThrow(
+          'Invalid ratio: must be a positive finite number',
+        );
+      });
+    });
+
+    describe('error handling - invalid defaultWidth', () => {
+      it('should throw error for zero defaultWidth', () => {
+        expect(() => adaptSizeToRatio(16 / 9, 0, 600)).toThrow(
+          'Invalid defaultWidth: must be a positive finite number',
+        );
+      });
+
+      it('should throw error for negative defaultWidth', () => {
+        expect(() => adaptSizeToRatio(16 / 9, -800, 600)).toThrow(
+          'Invalid defaultWidth: must be a positive finite number',
+        );
+      });
+
+      it('should throw error for NaN defaultWidth', () => {
+        expect(() => adaptSizeToRatio(16 / 9, NaN, 600)).toThrow(
+          'Invalid defaultWidth: must be a positive finite number',
+        );
+      });
+
+      it('should throw error for Infinity defaultWidth', () => {
+        expect(() => adaptSizeToRatio(16 / 9, Infinity, 600)).toThrow(
+          'Invalid defaultWidth: must be a positive finite number',
+        );
+      });
+    });
+
+    describe('error handling - invalid defaultHeight', () => {
+      it('should throw error for zero defaultHeight', () => {
+        expect(() => adaptSizeToRatio(16 / 9, 800, 0)).toThrow(
+          'Invalid defaultHeight: must be a positive finite number',
+        );
+      });
+
+      it('should throw error for negative defaultHeight', () => {
+        expect(() => adaptSizeToRatio(16 / 9, 800, -600)).toThrow(
+          'Invalid defaultHeight: must be a positive finite number',
+        );
+      });
+
+      it('should throw error for NaN defaultHeight', () => {
+        expect(() => adaptSizeToRatio(16 / 9, 800, NaN)).toThrow(
+          'Invalid defaultHeight: must be a positive finite number',
+        );
+      });
+
+      it('should throw error for Infinity defaultHeight', () => {
+        expect(() => adaptSizeToRatio(16 / 9, 800, Infinity)).toThrow(
+          'Invalid defaultHeight: must be a positive finite number',
+        );
+      });
+    });
+
+    describe('error handling - multiple invalid parameters', () => {
+      it('should validate ratio first before other parameters', () => {
+        // When multiple params are invalid, ratio is checked first
+        expect(() => adaptSizeToRatio(0, 0, 0)).toThrow(
+          'Invalid ratio: must be a positive finite number',
+        );
+      });
+
+      it('should validate defaultWidth before defaultHeight', () => {
+        // When ratio is valid but width and height are invalid
+        expect(() => adaptSizeToRatio(1.5, 0, 0)).toThrow(
+          'Invalid defaultWidth: must be a positive finite number',
+        );
+      });
+    });
+  });
+});