magpie-gemini-web 0.4.0 → 0.5.0

package/lib/studio-release.json

@@ -0,0 +1,27 @@
+{
+  "version": "0.2.12",
+  "repository": "Mag1cFall/AIStudio2API",
+  "tag": "v0.2.12",
+  "binaries": {
+    "darwin-x64": {
+      "asset": "aistudio2api-v0.2.12-darwin-amd64.tar.gz",
+      "sha256": "d7700be498293539c551671c582c4112997873593dcea6dee5cf9f23562f0331"
+    },
+    "darwin-arm64": {
+      "asset": "aistudio2api-v0.2.12-darwin-arm64.tar.gz",
+      "sha256": "a24bdc093e024e6c5d737ebdaed719c9cf5d6418c4f2edbf907f3c2979a9bb63"
+    },
+    "linux-x64": {
+      "asset": "aistudio2api-v0.2.12-linux-amd64.tar.gz",
+      "sha256": "fa2de6053b2bf8c8188cef39751a31bd0f88a07c67f34ad59a8bce29b0069b6a"
+    },
+    "linux-arm64": {
+      "asset": "aistudio2api-v0.2.12-linux-arm64.tar.gz",
+      "sha256": "32c9cbe63fa0b864f201e917aaa2c9b3b5a2be6c3f7734ad4f2328df7ed5e19c"
+    },
+    "win32-x64": {
+      "asset": "aistudio2api-v0.2.12-windows-amd64.zip",
+      "sha256": "e03235bc5aecc6e81c2c609ca4cc010afb6b88ce98ac87934603a59fe625b493"
+    }
+  }
+}

package/lib/studio.mjs

@@ -0,0 +1,641 @@
+import { normalizeBaseURL, credentials, forward, makeOpenAIError, UNREACHABLE_HEADER } from './backend.mjs';
+import { localStudio, ensureStudio, studioAdmin, studioAccounts, validateProxy, isConnectRefused } from './studio-native.mjs';
+
+export const STUDIO_ID = 'ai-studio';
+export const STUDIO_BASE = 'http://127.0.0.1:2048/v1';
+
+const STUDIO_EXCLUDE = /(?:image|nano-banana|tts|audio|live|transcribe|robotics|research|video|music|canvas)/i;
+// Catalog capabilities of models made for images, speech or live sessions. Such a model can be
+// marked chat_model and named like a text model too (gemini-omni-*), so the name can't tell.
+const NON_TEXT_CAPS = ['image_route', 'speech_route', 'live_route', 'aspect_ratio', 'output_resolution', 'interactions_api', 'transcription_output'];
+const CONTROL_CHARS = /[\x00-\x1f\x7f]/;
+
+// The service opens its own login window for a new account, and waits this long for it.
+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 分钟内完成登录；登录完成后可以关掉窗口，日常生成不需要浏览器。'
+];
+const LOGIN_STEPS = [
+  ...LOGIN_WINDOW,
+  '已经配置过也可以再来一次，添加更多 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}」`;
+
+const KNOWN_STUDIO_NESTED = new Set([
+  'baseURL',
+  'allowTools',
+  'allowImages',
+  'contextLimit',
+  'outputLimit',
+  'requestTimeoutMs',
+  'modelTimeoutMs',
+  'proxy',
+  'stripCitations'
+]);
+
+export function studioSettings(options = {}) {
+  if (!options || typeof options !== 'object' || Array.isArray(options)) {
+    throw new Error('Plugin options must be an object');
+  }
+
+  let allowTools = true;
+  if (options.allowTools !== undefined) {
+    if (typeof options.allowTools !== 'boolean') {
+      throw new Error('Invalid option allowTools: must be a boolean');
+    }
+    allowTools = options.allowTools;
+  }
+
+  let allowImages = false;
+  if (options.allowImages !== undefined) {
+    if (typeof options.allowImages !== 'boolean') {
+      throw new Error('Invalid option allowImages: must be a boolean');
+    }
+    allowImages = options.allowImages;
+  }
+
+  let requestTimeoutMs = 240000;
+  if (options.requestTimeoutMs !== undefined) {
+    if (!Number.isInteger(options.requestTimeoutMs) || options.requestTimeoutMs <= 0) {
+      throw new Error('Invalid option requestTimeoutMs: must be a positive integer');
+    }
+    requestTimeoutMs = options.requestTimeoutMs;
+  }
+
+  let modelTimeoutMs = 10000;
+  if (options.modelTimeoutMs !== undefined) {
+    if (!Number.isInteger(options.modelTimeoutMs) || options.modelTimeoutMs <= 0) {
+      throw new Error('Invalid option modelTimeoutMs: must be a positive integer');
+    }
+    modelTimeoutMs = options.modelTimeoutMs;
+  }
+
+  let baseURL = STUDIO_BASE;
+  let proxy;
+  let explicitContextLimit = null;
+  let explicitOutputLimit = null;
+
+  if (options.studio !== undefined) {
+    if (!options.studio || typeof options.studio !== 'object' || Array.isArray(options.studio)) {
+      throw new Error('Invalid option studio: must be an object');
+    }
+    for (const key of Object.keys(options.studio)) {
+      if (!KNOWN_STUDIO_NESTED.has(key)) {
+        throw new Error(`Unknown studio option: ${key}`);
+      }
+    }
+
+    const s = options.studio;
+    if (s.stripCitations !== undefined && s.stripCitations !== false) {
+      throw new Error('Invalid option stripCitations: AI Studio citations cannot be stripped (must be false)');
+    }
+
+    if (s.baseURL !== undefined) {
+      baseURL = normalizeBaseURL(s.baseURL);
+    }
+    if (s.proxy !== undefined) {
+      proxy = validateProxy(s.proxy);
+    }
+    if (s.allowTools !== undefined) {
+      if (typeof s.allowTools !== 'boolean') {
+        throw new Error('Invalid option studio.allowTools: must be a boolean');
+      }
+      allowTools = s.allowTools;
+    }
+    if (s.allowImages !== undefined) {
+      if (typeof s.allowImages !== 'boolean') {
+        throw new Error('Invalid option studio.allowImages: must be a boolean');
+      }
+      allowImages = s.allowImages;
+    }
+    if (s.requestTimeoutMs !== undefined) {
+      if (!Number.isInteger(s.requestTimeoutMs) || s.requestTimeoutMs <= 0) {
+        throw new Error('Invalid option studio.requestTimeoutMs: must be a positive integer');
+      }
+      requestTimeoutMs = s.requestTimeoutMs;
+    }
+    if (s.modelTimeoutMs !== undefined) {
+      if (!Number.isInteger(s.modelTimeoutMs) || s.modelTimeoutMs <= 0) {
+        throw new Error('Invalid option studio.modelTimeoutMs: must be a positive integer');
+      }
+      modelTimeoutMs = s.modelTimeoutMs;
+    }
+    if (s.contextLimit !== undefined) {
+      if (!Number.isInteger(s.contextLimit) || s.contextLimit <= 0) {
+        throw new Error('Invalid option studio.contextLimit: must be a positive integer');
+      }
+      explicitContextLimit = s.contextLimit;
+    }
+    if (s.outputLimit !== undefined) {
+      if (!Number.isInteger(s.outputLimit) || s.outputLimit <= 0) {
+        throw new Error('Invalid option studio.outputLimit: must be a positive integer');
+      }
+      explicitOutputLimit = s.outputLimit;
+    }
+    if (explicitContextLimit !== null && explicitOutputLimit !== null && explicitOutputLimit > explicitContextLimit) {
+      throw new Error('Invalid option studio.outputLimit: cannot exceed contextLimit');
+    }
+  }
+
+  return {
+    baseURL,
+    allowTools,
+    allowImages,
+    requestTimeoutMs,
+    modelTimeoutMs,
+    proxy,
+    stripCitations: false,
+    nativeThinking: true,
+    explicitContextLimit,
+    explicitOutputLimit
+  };
+}
+
+export async function listStudioModels(c, opts) {
+  const url = `${c.baseURL}/models`;
+  let res;
+  try {
+    res = await fetch(url, {
+      method: 'GET',
+      headers: {
+        'Authorization': `Bearer ${c.key}`,
+        'Accept': 'application/json'
+      },
+      redirect: 'error',
+      signal: AbortSignal.timeout(opts.modelTimeoutMs)
+    });
+  } catch (err) {
+    const error = new Error('Failed to reach AI Studio backend models endpoint: ' + (err?.message || err));
+    error.status = 502;
+    error.unreachable = true;
+    throw error;
+  }
+
+  if (!res.ok) {
+    const error = new Error(`Failed to list AI Studio models: HTTP ${res.status}`);
+    error.status = res.status;
+    if (res.status === 401) {
+      error.signIn = 'expired';
+    }
+    throw error;
+  }
+
+  let body;
+  try {
+    body = await res.json();
+  } catch {
+    throw new Error('Invalid models response: failed to parse JSON');
+  }
+
+  if (!body || typeof body !== 'object' || !Array.isArray(body.data)) {
+    throw new Error('Invalid models response: expected data array');
+  }
+
+  const result = Object.create(null);
+  const seen = new Set();
+  // A model no enabled account's subscription covers is listed without channels, and calls to it
+  // get a 403. A backend that lists no channels at all is older than that rule: keep its models.
+  const listsChannels = body.data.some(item => Array.isArray(item?.channels));
+
+  for (const item of body.data) {
+    if (!item || typeof item !== 'object' || typeof item.id !== 'string') {
+      throw new Error('Invalid model entry in response: expected object with string id');
+    }
+    const id = item.id;
+    if (!id || CONTROL_CHARS.test(id)) {
+      throw new Error('Invalid model entry in response: invalid id format');
+    }
+    if (!id.startsWith('gemini-')) continue;
+    if (STUDIO_EXCLUDE.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 (NON_TEXT_CAPS.some(cap => caps[cap] === true)) continue;
+    if (listsChannels && !(Array.isArray(item.channels) && item.channels.length > 0)) continue;
+
+    if (seen.has(id)) continue;
+    seen.add(id);
+
+    const upstreamInput = Number.isInteger(item.input_token_limit) && item.input_token_limit > 0
+      ? item.input_token_limit
+      : 1000000;
+    const upstreamOutput = Number.isInteger(item.output_token_limit) && item.output_token_limit > 0
+      ? item.output_token_limit
+      : 8192;
+
+    let context = opts.explicitContextLimit ? Math.min(upstreamInput, opts.explicitContextLimit) : upstreamInput;
+    let output = opts.explicitOutputLimit ? Math.min(upstreamOutput, opts.explicitOutputLimit) : upstreamOutput;
+    output = Math.min(output, context);
+
+    const toolcall = Boolean(opts.allowTools && caps.function_declarations === true);
+    const reasoning = Boolean(caps.thinking === true || caps.thinking_level === true);
+    // Of the levels the backend takes, none is the lowest one again and xhigh/max are high.
+    const variants = caps.thinking_level === true ? { minimal: {}, low: {}, medium: {}, high: {} } : {};
+    const image = Boolean(opts.allowImages && caps.media_resolution === true);
+
+    result[id] = {
+      id,
+      providerID: STUDIO_ID,
+      name: item.name || id,
+      api: {
+        id,
+        url: c.baseURL,
+        npm: '@ai-sdk/openai-compatible'
+      },
+      limit: {
+        context,
+        output
+      },
+      capabilities: {
+        temperature: true,
+        reasoning,
+        attachment: image,
+        toolcall,
+        input: {
+          text: true,
+          image
+        },
+        output: {
+          text: true
+        }
+      },
+      cost: {
+        input: 0,
+        output: 0,
+        cache: {
+          read: 0,
+          write: 0
+        }
+      },
+      options: {},
+      headers: {},
+      variants,
+      status: 'active'
+    };
+  }
+
+  if (Object.keys(result).length === 0) {
+    throw new Error('No usable Gemini models found in AI Studio response');
+  }
+
+  return result;
+}
+
+function sameBackend(c, local) {
+  return c.key === local.apiKey && c.baseURL === local.baseURL;
+}
+
+function managedMismatch() {
+  const err = new Error('Managed AI Studio key or baseURL mismatch; please re-authenticate');
+  err.signIn = 'expired';
+  return err;
+}
+
+// staleManagedSignIn says whether a managed sign-in names a key or URL the local service no
+// longer has. Without a local setup there is nothing to tell by: the request finds out when it
+// reaches the service, which is installed again if it is down. Unusable credentials are left to
+// forward(), which answers them as an expired sign-in.
+function staleManagedSignIn(auth, opts) {
+  const local = localStudio(opts);
+  if (!local) return false;
+  let c;
+  try {
+    c = credentials(auth, opts);
+  } catch {
+    return false;
+  }
+  return !sameBackend(c, local);
+}
+
+async function forwardManagedStudio(input, init, getAuth, opts) {
+  const retryInput = input instanceof Request ? input.clone() : input;
+
+  const auth = await getAuth();
+  if (auth?.metadata?.managed === true && staleManagedSignIn(auth, opts)) {
+    return makeOpenAIError(401, 'Managed AI Studio key or baseURL changed; sign in to AI Studio again');
+  }
+
+  const callerSignal = input instanceof Request ? input.signal : init?.signal;
+  const res = await forward(input, init, getAuth, { ...opts, nativeThinking: true, stripCitations: false });
+  if (res.headers.get(UNREACHABLE_HEADER) !== 'unreachable') return res;
+
+  if (callerSignal?.aborted) return res;
+  if (!auth?.metadata?.managed) return res;
+
+  try {
+    await ensureStudio({ ...opts, proxy: opts.proxy });
+  } catch {
+    return res;
+  }
+
+  if (callerSignal?.aborted) return res;
+  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) {
+  return {
+    type: 'success',
+    key: local.apiKey,
+    metadata: { mode: 'studio', managed: true, baseURL: local.baseURL }
+  };
+}
+
+const SERVING_STATES = new Set(['ready', 'busy', 'cooldown']);
+const labelOf = a => String(a.label || a.id);
+
+// cooldownWindows is the usage card's windows for the pool's cooldowns (AdminCooldown, one for each
+// account and model): one window a model, as full as the share of its accounts cooling down on it,
+// so a full one is a model no account can serve now, and starting again when the first of them
+// does. A cooldown with no model stands for all of an account's models.
+export function cooldownWindows(cooldowns, accounts, now = Date.now()) {
+  const serving = accounts.filter(a => SERVING_STATES.has(a.state));
+  const byModel = new Map();
+  for (const c of cooldowns) {
+    const until = Date.parse(c?.until ?? '');
+    if (!c || !Number.isFinite(until) || until <= now) continue;
+    const model = typeof c.model_id === 'string' ? c.model_id : '';
+    const m = byModel.get(model) ?? { accounts: new Set(), until: Infinity, reasons: new Set() };
+    m.accounts.add(c.account_id);
+    m.until = Math.min(m.until, until);
+    if (typeof c.reason === 'string' && c.reason.trim()) m.reasons.add(c.reason.trim());
+    byModel.set(model, m);
+  }
+  const out = [];
+  for (const [model, m] of byModel) {
+    const serves = serving.filter(a => !model || !Array.isArray(a.models) || !a.models.length || a.models.includes(model)).length;
+    const total = Math.max(serves, m.accounts.size);
+    const [reason] = m.reasons;
+    const why = m.reasons.size === 1 && reason.length <= 40 ? `：${reason}` : '';
+    out.push({
+      name: model || '所有模型',
+      used: Math.round((m.accounts.size / total) * 100),
+      resetsAt: new Date(m.until).toISOString(),
+      display: `${m.accounts.size}/${total} 个账号冷却中${why}`
+    });
+  }
+  return out.sort((a, b) => b.used - a.used || 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: [] };
+  }
+  const expired = accounts.filter(a => a.state === 'auth_required').length;
+  const unavailable = accounts.filter(a => a.state === 'unavailable').length;
+  const named = accounts.length > 1 ? `${labelOf(accounts[0])} +${accounts.length - 1}` : labelOf(accounts[0]);
+  const notes = [];
+  if (expired) notes.push(`${expired} 个需要重新登录`);
+  if (unavailable) notes.push(`${unavailable} 个暂时不可用`);
+  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}」`
+      : '本地 AI Studio 的 Google 账号暂时都不可用';
+    return { user, error, windows: [] };
+  }
+  return { user, windows: cooldownWindows(cooldowns, accounts, now) };
+}
+
+export const AIStudioPlugin = async (_input, options = {}) => {
+  const opts = studioSettings(options);
+
+  if (localStudio(opts)) {
+    ensureStudio({ ...opts, proxy: opts.proxy }).catch(err => {
+      console.error(`[ai-studio] could not start the local AI Studio service: ${err.message}`);
+    });
+  }
+
+  // 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) {
+    ensureStudio({ proxy: opts.proxy }).catch(err => {
+      console.error(`[ai-studio] generation did not start after sign-in: ${err.message}`);
+    });
+    return poolSignIn(local);
+  }
+
+  // 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);
+    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 {
+    config: async cfg => {
+      cfg.provider ??= {};
+      cfg.provider[STUDIO_ID] ??= {
+        name: 'Google AI Studio',
+        npm: '@ai-sdk/openai-compatible',
+        api: opts.baseURL,
+        models: {}
+      };
+    },
+    auth: {
+      provider: STUDIO_ID,
+      maxConcurrency: 1,
+      methods: [
+        {
+          type: 'oauth',
+          label: SETUP_METHOD,
+          async authorize() {
+            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();
+            return {
+              type: 'select',
+              key: 'account',
+              message: '选择要重新登录的 Google 账号',
+              placeholder: '',
+              options: accounts.map(a => ({ label: labelOf(a), value: a.id, hint: a.message || '需要重新登录' }))
+            };
+          },
+          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);
+              }
+            };
+          }
+        },
+        {
+          type: 'api',
+          label: '连接已有 AIStudio2API（地址 + API key）',
+          placeholder: 'AIStudio2API PROXY_API_KEY',
+          prompts: [{
+            type: 'text',
+            key: 'baseURL',
+            message: 'AIStudio2API base URL (blank: default http://127.0.0.1:2048/v1)',
+            placeholder: opts.baseURL,
+            validate: value => {
+              try {
+                normalizeBaseURL(value || opts.baseURL);
+              } catch (e) {
+                return e.message;
+              }
+            }
+          }],
+          authorize: async inputs => ({
+            type: 'success',
+            metadata: {
+              mode: 'studio',
+              managed: false,
+              baseURL: normalizeBaseURL(inputs?.baseURL || opts.baseURL)
+            }
+          })
+        }
+      ],
+      async loader(getAuth) {
+        const auth = await getAuth();
+        if (auth?.type !== 'api') return {};
+        const c = credentials(auth, opts);
+        if (auth.metadata?.managed === true) {
+          // Bring the service up (installing it again if it went missing) before comparing:
+          // only a setup that is there can tell that the sign-in's key is no longer its own.
+          const local = await ensureStudio({ proxy: opts.proxy });
+          if (!sameBackend(c, local)) throw managedMismatch();
+        }
+        return {
+          apiKey: c.key,
+          baseURL: c.baseURL,
+          fetch: (input, init) => forwardManagedStudio(input, init, getAuth, opts)
+        };
+      },
+      async usage(getAuth) {
+        const auth = await getAuth();
+        if (auth?.type !== 'api') return { error: 'AI Studio 还没有登录', windows: [], signIn: 'kept' };
+        if (!auth.metadata?.managed) {
+          return { error: '连接已有 AIStudio2API 时读不到本地账户状态（外部服务不提供管理接口）', windows: [], signIn: 'kept' };
+        }
+        let c;
+        try {
+          c = credentials(auth, opts);
+        } catch (err) {
+          return { error: err.message, windows: [], signIn: 'kept' };
+        }
+        const local = localStudio(opts);
+        if (!local) {
+          return { error: '本地 AI Studio 服务还没有装好，下一次请求时会自动安装', windows: [], signIn: 'kept' };
+        }
+        if (!sameBackend(c, local)) {
+          return { error: '本地 AI Studio 配置不匹配，请重新登录', windows: [], signIn: 'expired' };
+        }
+
+        let accounts, cooldowns;
+        try {
+          [accounts, cooldowns] = await Promise.all([
+            studioAdmin(local, 'GET', '/api/accounts', null, { timeoutMs: 3000 }),
+            // Without its cooldowns the card still says whose accounts these are.
+            studioAdmin(local, 'GET', '/api/cooldowns', null, { timeoutMs: 3000 }).catch(() => null)
+          ]);
+        } catch (err) {
+          if (isConnectRefused(err)) {
+            return { error: '本地 AI Studio 服务没有在运行，下一次请求时会自动启动', windows: [], signIn: 'kept' };
+          }
+          return { error: `无法读取本地 AI Studio 状态: ${err.message}`, windows: [], signIn: 'kept' };
+        }
+        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' };
+      }
+    },
+    provider: {
+      id: STUDIO_ID,
+      async models(provider, { auth } = {}) {
+        if (auth?.type !== 'api') return provider.models;
+        const c = credentials(auth, opts);
+        if (auth.metadata?.managed === true) {
+          const local = await ensureStudio({ proxy: opts.proxy });
+          if (!sameBackend(c, local)) throw managedMismatch();
+        }
+        try {
+          return await listStudioModels(c, opts);
+        } catch (err) {
+          if (!err.unreachable || !auth.metadata?.managed) throw err;
+          await ensureStudio({ ...opts, proxy: opts.proxy });
+          return listStudioModels(c, opts);
+        }
+      }
+    }
+  };
+};
+
+export default AIStudioPlugin;

package/native-task/README.md

@@ -29,7 +29,9 @@
 
 2026-10-15：已执行通过 41 项 Python 测试和 12 项 Node 测试；真实 Magpie `0.1.1244` 的隔离环境完成了插件安装、本地连接、模型发现及 8 个 HTTP 请求的工具往返测试。该网关测试使用模拟原生上游，包含两次串行工具、最终答案重试、错误会话/调用 ID 拒绝、旧工具阶段拒绝和下一轮用户消息。
 
-当前实现已使用现有登录完成 OAuth 续期及保存轮次读取，但真实 Task 请求被 Google 返回的 `Remy quota exhausted`（gRPC 8）拒绝，尚未完成本版真实 Argon 工具端到端验收。服务将该错误映射为 `native_quota_exhausted`，不会自动重发 Task。
+2026-10-15：通过 `magpie-gemini-web` 0.4.0 的 Task 登录方式（直接加载插件，未经 Magpie 网关）完成了一次真实 Argon 工具往返：模型返回 `Read` 工具调用（19.2 秒），回传工具结果后得到正确的最终答案（13.7 秒）。此前真实 Task 请求曾被 Google 以 `Remy quota exhausted`（gRPC 8）拒绝，服务将该错误映射为 `native_quota_exhausted`，不会自动重发 Task。
+
+已知问题：客户端收到工具调用后若不回传结果（例如 agent 中途被打断），该 Task 会一直占用唯一的名额，直到工具等待和任务超时到期（最长约 4 分钟），期间其他请求返回 409 `concurrency_limit`。另外曾出现过一次首个健康检查超时（2 秒），未能复现。
 
 ## Magpie 插件安装与登录