magpie-gemini-web 0.5.0 → 0.5.2

package/lib/studio.mjs

@@ -15,18 +15,28 @@ const LOGIN_TIMEOUT_MS = 15 * 60 * 1000;
 // Upstream logs in with Camoufox even when generation runs in Go, and downloads it on the first
 // login, so that one can take minutes before a window shows.
 const LOGIN_WINDOW = [
-  '即将打开独立的 Google 登录窗口（不影响你平时用的浏览器）。',
-  '第一次登录要先下载登录用的浏览器 Camoufox，可能要等几分钟窗口才出现。',
-  '请在 15 分钟内完成登录；登录完成后可以关掉窗口，日常生成不需要浏览器。'
+  '第一次登录要先下载登录用的浏览器 Camoufox（约 300 MB），可能要等几分钟窗口才出现，期间这里没有变化，请耐心等待。',
+  '登录窗口是独立的，不影响你平时用的浏览器；请在 15 分钟内完成登录，完成后可以关掉窗口，日常生成不需要浏览器。'
 ];
 const LOGIN_STEPS = [
   ...LOGIN_WINDOW,
-  '已经配置过也可以再来一次，添加更多 Google 账号：所有账号共用这一个登录，由本地服务自动轮换。'
+  '想加更多 Google 账号，再来一次即可，每个账号一张卡片。'
 ].join('\n');
 const RELOGIN_STEPS = LOGIN_WINDOW.join('\n');
-const SETUP_METHOD = '一键配置本地 Google AI Studio（推荐）';
-const RELOGIN_METHOD = '重新登录失效的 AI Studio 账号';
-const NO_LOCAL_STUDIO = `还没有本地 Google AI Studio 服务：请先用「${SETUP_METHOD}」`;
+// AdminAccount.state as the account list shows it
+const ACCOUNT_STATES = {
+  ready: '可用',
+  busy: '使用中',
+  cooldown: '冷却中',
+  auth_required: '需要重新登录',
+  unavailable: '暂时不可用',
+  disabled: '已停用'
+};
+const SIGN_IN_METHOD = '用 Google 账号登录（推荐）';
+// How to sign an account in again, or add one, as messages say it
+const SIGN_IN_HOW = `在 Magpie 里登录 Google AI Studio，选「${SIGN_IN_METHOD}」`;
+// The choice of a new account among the local service's (whose ids are emails, so none is this)
+const NEW_ACCOUNT = '+new';
 
 const KNOWN_STUDIO_NESTED = new Set([
   'baseURL',
@@ -61,7 +71,7 @@ export function studioSettings(options = {}) {
     allowImages = options.allowImages;
   }
 
-  let requestTimeoutMs = 240000;
+  let requestTimeoutMs = 30 * 60 * 1000;
   if (options.requestTimeoutMs !== undefined) {
     if (!Number.isInteger(options.requestTimeoutMs) || options.requestTimeoutMs <= 0) {
       throw new Error('Invalid option requestTimeoutMs: must be a positive integer');
@@ -213,13 +223,15 @@ export async function listStudioModels(c, opts) {
       throw new Error('Invalid model entry in response: invalid id format');
     }
     if (!id.startsWith('gemini-')) continue;
-    if (STUDIO_EXCLUDE.test(id)) continue;
+    // Build assistant models inject Google's coding-agent prompt and do not expose
+    // ordinary function calling. Keep them out of this general-purpose provider.
+    if (STUDIO_EXCLUDE.test(id) || /-build$/i.test(id)) continue;
 
     const methods = Array.isArray(item.supported_generation_methods) ? item.supported_generation_methods : [];
     if (!methods.includes('generateContent')) continue;
 
     const caps = item.capabilities && typeof item.capabilities === 'object' ? item.capabilities : {};
-    if (caps.chat_model !== true) continue;
+    if (caps.chat_model !== true || caps.assistant_route === true) continue;
     if (NON_TEXT_CAPS.some(cap => caps[cap] === true)) continue;
     if (listsChannels && !(Array.isArray(item.channels) && item.channels.length > 0)) continue;
 
@@ -342,15 +354,16 @@ async function forwardManagedStudio(input, init, getAuth, opts) {
   return forward(retryInput, init, getAuth, { ...opts, nativeThinking: true, stripCitations: false });
 }
 
-// poolSignIn is the Magpie sign-in for the local service: its key, which serves every account
-// signed in to it. The service picks the account for each request itself (fill-first), so a
-// sign-in can't pin one, and none is named: Magpie takes two sign-ins with no email and the same
-// key for one, so signing in again, as adding another account does, keeps the one card.
-function poolSignIn(local) {
+// accountSignIn is the Magpie sign-in for one Google account of the local service: the service's
+// key, with the account's id for its usage card and its email (the account's label, or its id,
+// which upstream makes the lowercased email), which names the card and keeps each account a
+// sign-in of its own, as Gemini Web's are. The service still picks the account for each request
+// itself (fill-first): a sign-in can't pin one.
+function accountSignIn(local, account) {
   return {
     type: 'success',
     key: local.apiKey,
-    metadata: { mode: 'studio', managed: true, baseURL: local.baseURL }
+    metadata: { mode: 'studio', managed: true, baseURL: local.baseURL, account: account.id, email: labelOf(account) }
   };
 }
 
@@ -390,13 +403,40 @@ export function cooldownWindows(cooldowns, accounts, now = Date.now()) {
   return out.sort((a, b) => b.used - a.used || Date.parse(a.resetsAt) - Date.parse(b.resetsAt));
 }
 
+// accountUsage is the usage card of one account of the local service: its own cooldowns, one
+// window a model (or one for all its models), full until the cooldown ends; an account that can't
+// serve says why instead.
+export function accountUsage(account, cooldowns, now = Date.now()) {
+  const user = labelOf(account);
+  if (account.state === 'auth_required') {
+    return { user, error: `这个 Google 账号需要重新登录：${SIGN_IN_HOW}，再选这个账号`, windows: [] };
+  }
+  if (!SERVING_STATES.has(account.state)) {
+    const why = ACCOUNT_STATES[account.state] || account.state || '暂时不可用';
+    return { user, error: `这个 Google 账号${why}${account.message ? `：${account.message}` : ''}`, windows: [] };
+  }
+  const windows = [];
+  for (const c of cooldowns) {
+    const until = Date.parse(c?.until ?? '');
+    if (c?.account_id !== account.id || !Number.isFinite(until) || until <= now) continue;
+    const reason = typeof c.reason === 'string' ? c.reason.trim() : '';
+    windows.push({
+      name: typeof c.model_id === 'string' && c.model_id ? c.model_id : '所有模型',
+      used: 100,
+      resetsAt: new Date(until).toISOString(),
+      display: reason && reason.length <= 40 ? `冷却中：${reason}` : '冷却中'
+    });
+  }
+  return { user, windows: windows.sort((a, b) => Date.parse(a.resetsAt) - Date.parse(b.resetsAt)) };
+}
+
 // poolUsage is the usage card of the local service's accounts: they go by their labels (Google
 // emails), with the ones that can't serve counted beside them. The service gives no allowance to
 // show, only the models its accounts cool down on (see cooldownWindows); a pool none of whose
 // accounts can serve until one signs in again is an error, since every request fails.
 export function poolUsage(accounts, cooldowns, now = Date.now()) {
   if (!accounts.length) {
-    return { error: `本地 AI Studio 里还没有 Google 账号：在 Magpie 里登录 AI Studio，选「${SETUP_METHOD}」`, windows: [] };
+    return { error: `本地 AI Studio 里还没有 Google 账号：${SIGN_IN_HOW}`, windows: [] };
   }
   const expired = accounts.filter(a => a.state === 'auth_required').length;
   const unavailable = accounts.filter(a => a.state === 'unavailable').length;
@@ -407,7 +447,7 @@ export function poolUsage(accounts, cooldowns, now = Date.now()) {
   const user = notes.length ? `${named}（${notes.join('，')}）` : named;
   if (!accounts.some(a => SERVING_STATES.has(a.state))) {
     const error = expired
-      ? `${expired} 个 Google 账号都需要重新登录：在 Magpie 里登录 AI Studio，选「${RELOGIN_METHOD}」`
+      ? `${expired} 个 Google 账号都需要重新登录：${SIGN_IN_HOW}，再选要重新登录的账号`
       : '本地 AI Studio 的 Google 账号暂时都不可用';
     return { user, error, windows: [] };
   }
@@ -426,20 +466,56 @@ export const AIStudioPlugin = async (_input, options = {}) => {
   // afterLogin is the sign-in once an account is signed in. Generation may still be starting;
   // the first request waits for it, so a slow start doesn't fail a sign-in that worked (and a
   // retry doesn't open another login window for the same account).
-  function afterLogin(local) {
+  function afterLogin(local, account) {
     ensureStudio({ proxy: opts.proxy }).catch(err => {
       console.error(`[ai-studio] generation did not start after sign-in: ${err.message}`);
     });
-    return poolSignIn(local);
+    return accountSignIn(local, account);
   }
 
-  // expiredAccounts is the enabled accounts that need to sign in again, of a setup already here.
-  async function expiredAccounts() {
-    if (!localStudio(opts)) throw new Error(NO_LOCAL_STUDIO);
+  // addAccount signs a new Google account in through the service's own login window, setting the
+  // service up first if this is the first.
+  async function addAccount() {
     await ensureStudio({ proxy: opts.proxy, managementOnly: true });
-    const accounts = (await studioAccounts(opts)).filter(a => a.state === 'auth_required');
-    if (!accounts.length) throw new Error('本地 Google AI Studio 里没有需要重新登录的账号');
-    return accounts;
+    return {
+      url: '',
+      method: 'auto',
+      instructions: LOGIN_STEPS,
+      async callback() {
+        let local, account;
+        try {
+          local = await ensureStudio({ proxy: opts.proxy, managementOnly: true });
+          const res = await studioAdmin(local, 'POST', '/api/accounts', {}, { timeoutMs: LOGIN_TIMEOUT_MS });
+          account = res?.account;
+          if (!account || typeof account.id !== 'string' || !account.id || account.enabled === false) {
+            throw new Error('AIStudio2API did not return an enabled account');
+          }
+        } catch (err) {
+          return { type: 'failed', error: `Google 登录没有完成：${err.message}` };
+        }
+        return afterLogin(local, account);
+      }
+    };
+  }
+
+  // signInAgain signs an account whose Google sign-in expired in again, in a login window.
+  function signInAgain(chosen) {
+    return {
+      url: '',
+      method: 'auto',
+      instructions: RELOGIN_STEPS,
+      async callback() {
+        let local;
+        try {
+          local = await ensureStudio({ proxy: opts.proxy, managementOnly: true });
+          const res = await studioAdmin(local, 'POST', `/api/accounts/${encodeURIComponent(chosen.id)}/login`, {}, { timeoutMs: LOGIN_TIMEOUT_MS });
+          if (res?.account?.state === 'auth_required') throw new Error(res.account.message || '账号仍然需要重新登录');
+        } catch (err) {
+          return { type: 'failed', error: `${labelOf(chosen)} 没有重新登录：${err.message}` };
+        }
+        return afterLogin(local, chosen);
+      }
+    };
   }
 
   return {
@@ -457,83 +533,39 @@ export const AIStudioPlugin = async (_input, options = {}) => {
       maxConcurrency: 1,
       methods: [
         {
+          // One way in for a Google account: a new one, one the local service already has, or one
+          // of those to sign in again. The first time there is no service yet, and nothing to ask.
           type: 'oauth',
-          label: SETUP_METHOD,
-          async authorize() {
+          label: SIGN_IN_METHOD,
+          prompts: [{ type: 'select', key: 'account', message: '选择 Google 账号', options: [] }],
+          async ask(inputs) {
+            if (inputs?.account || !localStudio(opts)) return null;
             await ensureStudio({ proxy: opts.proxy, managementOnly: true });
-            return {
-              url: '',
-              method: 'auto',
-              instructions: LOGIN_STEPS,
-              async callback() {
-                let local;
-                try {
-                  local = await ensureStudio({ proxy: opts.proxy, managementOnly: true });
-                  const res = await studioAdmin(local, 'POST', '/api/accounts', {}, { timeoutMs: LOGIN_TIMEOUT_MS });
-                  const account = res?.account;
-                  if (!account || typeof account.id !== 'string' || !account.id || account.enabled === false) {
-                    throw new Error('AIStudio2API did not return an enabled account');
-                  }
-                } catch (err) {
-                  return { type: 'failed', error: `Google 登录没有完成：${err.message}` };
-                }
-                return afterLogin(local);
-              }
-            };
-          }
-        },
-        {
-          type: 'oauth',
-          label: '使用本机已有的 AI Studio 服务',
-          async authorize() {
-            // Only a setup that is already here has accounts to use: don't install one.
-            if (!localStudio(opts)) throw new Error(NO_LOCAL_STUDIO);
-            const local = await ensureStudio({ proxy: opts.proxy, managementOnly: true });
             const accounts = await studioAccounts(opts);
-            if (!accounts.length) throw new Error(`本地 Google AI Studio 里没有启用的 Google 账号：请用「${SETUP_METHOD}」添加`);
-            return {
-              url: '',
-              method: 'auto',
-              instructions: '',
-              callback: async () => poolSignIn(local)
-            };
-          }
-        },
-        {
-          type: 'oauth',
-          label: RELOGIN_METHOD,
-          prompts: [{ type: 'select', key: 'account', message: '选择要重新登录的 Google 账号', options: [] }],
-          async ask(inputs) {
-            if (inputs?.account) return null;
-            const accounts = await expiredAccounts();
+            if (!accounts.length) return null;
             return {
               type: 'select',
               key: 'account',
-              message: '选择要重新登录的 Google 账号',
+              message: '选择 Google 账号',
               placeholder: '',
-              options: accounts.map(a => ({ label: labelOf(a), value: a.id, hint: a.message || '需要重新登录' }))
+              options: [
+                { label: '添加新的 Google 账号', value: NEW_ACCOUNT, hint: '打开登录窗口' },
+                ...accounts.map(a => ({
+                  label: labelOf(a),
+                  value: a.id,
+                  hint: a.state === 'auth_required' ? '需要重新登录：会打开登录窗口' : ACCOUNT_STATES[a.state] || a.state || ''
+                }))
+              ]
             };
           },
           async authorize(inputs) {
-            const accounts = await expiredAccounts();
-            const chosen = accounts.find(a => a.id === inputs?.account);
-            if (!chosen) throw new Error(`账号 ${inputs?.account ?? ''} 不需要重新登录`);
-            return {
-              url: '',
-              method: 'auto',
-              instructions: RELOGIN_STEPS,
-              async callback() {
-                let local;
-                try {
-                  local = await ensureStudio({ proxy: opts.proxy, managementOnly: true });
-                  const res = await studioAdmin(local, 'POST', `/api/accounts/${encodeURIComponent(chosen.id)}/login`, {}, { timeoutMs: LOGIN_TIMEOUT_MS });
-                  if (res?.account?.state === 'auth_required') throw new Error(res.account.message || '账号仍然需要重新登录');
-                } catch (err) {
-                  return { type: 'failed', error: `${labelOf(chosen)} 没有重新登录：${err.message}` };
-                }
-                return afterLogin(local);
-              }
-            };
+            const id = inputs?.account;
+            if (!id || id === NEW_ACCOUNT) return addAccount();
+            const local = await ensureStudio({ proxy: opts.proxy, managementOnly: true });
+            const chosen = (await studioAccounts(opts)).find(a => a.id === id);
+            if (!chosen) throw new Error(`本地 Google AI Studio 里没有启用的账号 ${id}`);
+            if (chosen.state === 'auth_required') return signInAgain(chosen);
+            return { url: '', method: 'auto', instructions: '', callback: async () => accountSignIn(local, chosen) };
           }
         },
         {
@@ -614,7 +646,16 @@ export const AIStudioPlugin = async (_input, options = {}) => {
         }
         const enabled = (Array.isArray(accounts?.accounts) ? accounts.accounts : []).filter(a => a && a.enabled !== false);
         const cooling = Array.isArray(cooldowns?.cooldowns) ? cooldowns.cooldowns : [];
-        return { ...poolUsage(enabled, cooling), signIn: 'kept' };
+        const id = auth.metadata.account;
+        if (typeof id !== 'string' || !id) {
+          // A sign-in for the whole pool, as 0.5.0 made them
+          return { ...poolUsage(enabled, cooling), signIn: 'kept' };
+        }
+        const account = enabled.find(a => a.id === id);
+        if (!account) {
+          return { error: `本地 AI Studio 里已经没有这个账号（${auth.metadata.email || id}），可能被停用或删除了`, windows: [], signIn: 'kept' };
+        }
+        return { ...accountUsage(account, cooling), signIn: 'kept' };
       }
     },
     provider: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "magpie-gemini-web",
-  "version": "0.5.0",
+  "version": "0.5.2",
   "description": "Gemini Web and Google AI Studio provider for Magpie, backed by gemini-web2api-go and AIStudio2API",
   "type": "module",
   "main": "./index.mjs",
@@ -25,6 +25,9 @@
     "scripts/backend-release.mjs",
     "scripts/studio-smoke.mjs",
     "scripts/studio.mjs",
+    "scripts/studio-release.mjs",
+    "scripts/studio-archive.go",
+    "scripts/studio-managed-smoke.mjs",
     "patches/",
     "native-task/lib/",
     "native-task/bridge/",
@@ -36,8 +39,10 @@
     "README.md",
     "README.en.md",
     "docs/backend-release.md",
+    "docs/studio-release.md",
     "LICENSE",
-    "LICENSE-UPSTREAM"
+    "LICENSE-UPSTREAM",
+    "LICENSE-AISTUDIO"
   ],
   "keywords": [
     "magpie-plugin",
@@ -61,6 +66,8 @@
     "backend:build:argon": "node scripts/backend-argon.mjs build",
     "backend:install:argon": "node scripts/backend-argon.mjs install",
     "backend:start:argon": "node scripts/backend-argon.mjs start",
+    "studio:release:build": "node scripts/studio-release.mjs --verify",
+    "studio:managed:smoke": "node scripts/studio-managed-smoke.mjs",
     "studio:install": "node scripts/studio.mjs install",
     "studio:start": "node scripts/studio.mjs start",
     "studio:status": "node scripts/studio.mjs status",