opencode-claude-code-ua 0.0.0-stage → 0.3.6

package/lib/ua-test-plan.mjs

@@ -0,0 +1,232 @@
+import { SDK_BY_PROTOCOL, protocolForModel, apiBase, operationURL } from './ua-protocol.mjs'
+
+const OPERATIONS = {
+  anthropic: ['messages', 'count_tokens'],
+  responses: ['responses'],
+  'chat-completions': ['chat/completions'],
+  gemini: ['generateContent', 'streamGenerateContent', 'countTokens'],
+}
+const BUILTIN_REFS = {
+  responses: { id: 'builtin.codex', revision: 1 },
+  anthropic: { id: 'builtin.claude-code', revision: 1 },
+}
+const CONTROL = /[\u0000-\u001f\u007f-\u009f]/
+const isObject = value => value !== null && typeof value === 'object' && !Array.isArray(value)
+const isCount = operation => operation === 'count_tokens' || operation === 'countTokens'
+const label = template => template ? `${template.name || template.id}@${template.revision}` : '普通转发'
+const fail = (message, field) => Object.assign(new Error(message), {
+  status: 400, code: 'test-plan-invalid', fields: { [field]: message },
+})
+
+function checked(field, action) {
+  try { return action() } catch (error) {
+    if (error?.code === 'test-plan-invalid') throw error
+    throw fail(error?.message || '测试计划无效', field)
+  }
+}
+
+function validateProtocol(protocol) {
+  if (!Object.hasOwn(SDK_BY_PROTOCOL, protocol)) throw fail('不支持的上游协议', 'protocol')
+}
+
+function validateModel(model) {
+  if (typeof model !== 'string' || !model.trim() || CONTROL.test(model)) throw fail('请选择有效的测试模型，模型名不能为空或包含控制字符', 'model')
+}
+
+function chooseOperation(protocol, operation, stream) {
+  validateProtocol(protocol)
+  if (typeof stream !== 'boolean') throw fail('测试 stream 必须是布尔值', 'stream')
+  const selected = operation ?? (protocol === 'gemini' && stream ? 'streamGenerateContent' : OPERATIONS[protocol][0])
+  if (!OPERATIONS[protocol].includes(selected)) throw fail('操作与上游协议不匹配', 'operation')
+  if (isCount(selected) && stream) throw fail('计数操作不支持流式测试', 'stream')
+  if (protocol === 'gemini' && !isCount(selected) && (selected === 'streamGenerateContent') !== stream) {
+    throw fail('Gemini 操作与测试 stream 不一致', 'stream')
+  }
+  return selected
+}
+
+function validateRef(ref, field) {
+  if (!isObject(ref) || typeof ref.id !== 'string' || !ref.id.trim() || CONTROL.test(ref.id) || !Number.isSafeInteger(ref.revision) || ref.revision < 1) {
+    throw fail('模板引用必须指定有效 id 和精确 revision', field)
+  }
+}
+
+function validateTemplateShape(template, field) {
+  validateRef(template, field)
+  if (template.schemaVersion !== 1 || typeof template.name !== 'string' || !template.name.trim() ||
+      !['builtin', 'custom'].includes(template.kind) || !Array.isArray(template.headers) || !isObject(template.body) ||
+      !Array.isArray(template.protocols) || !template.protocols.length ||
+      template.protocols.some(protocol => !Object.hasOwn(OPERATIONS, protocol)) ||
+      !Array.isArray(template.operations) || !template.operations.length ||
+      template.operations.some(operation => !template.protocols.some(protocol => OPERATIONS[protocol].includes(operation)))) {
+    throw fail('模板数据损坏，不能为测试自动回退', field)
+  }
+  return template
+}
+
+function findTemplate(snapshot, ref, field = 'templateRef', allowArchived = true) {
+  validateRef(ref, field)
+  if (!isObject(snapshot) || !Array.isArray(snapshot.templates)) throw fail('状态快照无效', 'snapshot')
+  const matches = snapshot.templates.filter(template => isObject(template) && template.id === ref.id && template.revision === ref.revision)
+  if (matches.length !== 1) throw fail(matches.length ? '模板版本重复，状态快照损坏' : '指定的模板 revision 不存在', field)
+  const template = validateTemplateShape(matches[0], field)
+  if (!allowArchived && template.archived) throw fail('本次自动兼容所需的固定内置模板已归档', field)
+  return template
+}
+
+function assertCompatible(template, protocol, operation) {
+  if (template && (!template.protocols.includes(protocol) || !template.operations.includes(operation))) {
+    throw fail('选择的模板不支持当前协议或操作，请明确选择兼容模板', 'template')
+  }
+}
+
+function autoTemplate(snapshot, binding, protocol) {
+  const versions = binding.resolvedVersions
+  if (versions !== undefined && !isObject(versions)) throw fail('auto 绑定的固定版本数据损坏', 'binding')
+  if (versions && Object.hasOwn(versions, protocol)) return findTemplate(snapshot, versions[protocol], 'binding')
+  if (protocol === 'chat-completions' || protocol === 'gemini') return null
+  throw fail('auto 绑定缺少当前协议的固定模板版本', 'binding')
+}
+
+function effectiveBinding(connection, model) {
+  if (connection.modelBindings !== undefined && !isObject(connection.modelBindings)) throw fail('模型模板绑定数据损坏', 'binding')
+  const binding = model && connection.modelBindings && Object.hasOwn(connection.modelBindings, model)
+    ? connection.modelBindings[model] : connection.binding
+  if (!isObject(binding)) throw fail('连接缺少模板绑定', 'binding')
+  return binding
+}
+
+function compatibleTemplate(snapshot, connection, binding, protocol) {
+  // An explicit configured auto reference is still pinned; invalid references never fall back.
+  const configured = binding.mode === 'auto' ? binding : connection.binding?.mode === 'auto' ? connection.binding : null
+  if (configured) return autoTemplate(snapshot, configured, protocol)
+  const ref = BUILTIN_REFS[protocol]
+  return ref ? findTemplate(snapshot, ref, 'binding', false) : null
+}
+
+function resolveSelection({ snapshot, connection, model, protocol, operation, templateMode, template, templateRef }) {
+  if (template === null) return { template: null, resolution: { mode: 'passthrough', message: '本次测试使用普通转发，不修改连接绑定' }, warnings: [] }
+  if (template !== undefined || templateRef !== undefined) {
+    const selected = template !== undefined ? validateTemplateShape(template, 'template') : findTemplate(snapshot, templateRef)
+    assertCompatible(selected, protocol, operation)
+    return { template: selected, resolution: { mode: 'explicit', message: `本次测试使用${label(selected)}，不修改连接绑定` }, warnings: [] }
+  }
+  const binding = effectiveBinding(connection, model)
+  let selected
+  if (binding.mode === 'passthrough') selected = null
+  else if (binding.mode === 'auto') selected = autoTemplate(snapshot, binding, protocol)
+  else if (binding.mode === 'template') selected = findTemplate(snapshot, binding, 'binding')
+  else throw fail('模板绑定模式无效', 'binding')
+
+  const protocolMatches = selected === null || selected.protocols.includes(protocol)
+  const operationMatches = selected === null || selected.operations.includes(operation)
+  if (!protocolMatches || !operationMatches) {
+    // Counting must not hide a same-protocol template's deliberately unsupported operation.
+    if (templateMode !== 'auto' || (protocolMatches && isCount(operation))) assertCompatible(selected, protocol, operation)
+    const compatible = compatibleTemplate(snapshot, connection, binding, protocol)
+    assertCompatible(compatible, protocol, operation)
+    return {
+      template: compatible,
+      resolution: { mode: 'compatible', message: `本次测试改用${label(compatible)}；连接仍绑定${label(selected)}` },
+      warnings: ['仅用于本次测试，不修改连接或模型的模板绑定。'],
+    }
+  }
+  return {
+    template: selected,
+    resolution: { mode: selected ? 'binding' : 'passthrough', message: selected ? `使用绑定模板${label(selected)}` : '使用绑定的普通转发策略' },
+    warnings: [],
+  }
+}
+
+/** Build an immutable-input, credential-free plan. The caller owns transport and authentication. */
+export function createTestPlan({ snapshot, connection, kind = 'infer', protocol, operation, model = '', stream = false, templateMode = 'binding', template, templateRef, apiPath } = {}) {
+  if (!['preview', 'check', 'infer'].includes(kind)) throw fail('测试类型无效', 'kind')
+  if (!['binding', 'auto'].includes(templateMode)) throw fail('测试模板模式无效', 'templateMode')
+  if (typeof stream !== 'boolean') throw fail('测试 stream 必须是布尔值', 'stream')
+  if (!isObject(connection)) {
+    if (kind !== 'preview' || connection != null) throw fail('请选择测试连接', 'connection')
+    validateProtocol(protocol)
+    connection = { baseURL: 'https://preview.invalid', protocol, binding: { mode: 'auto', resolvedVersions: BUILTIN_REFS } }
+  }
+  if (kind === 'check') {
+    protocol = checked('protocol', () => protocolForModel(connection, ''))
+    model = ''
+    operation = 'models'
+    stream = false
+  } else {
+    validateModel(model)
+    protocol = protocol ?? checked('protocol', () => protocolForModel(connection, model))
+    operation = chooseOperation(protocol, operation, stream)
+  }
+  validateProtocol(protocol)
+  // Never spread the connection: doing so could read/copy a credential getter or secret value.
+  const target = { baseURL: connection.baseURL, apiPaths: connection.apiPaths }
+  if (apiPath !== undefined) {
+    if (typeof apiPath !== 'string' || !/^\/[A-Za-z0-9/_-]*$/.test(apiPath) || apiPath.includes('//')) {
+      throw fail('本次协议根路径必须以 / 开头，且不能包含 URL、重复斜杠、遍历、查询或片段', 'apiPath')
+    }
+    if (/\/(?:messages(?:\/count_tokens)?|responses|chat\/completions)$/.test(apiPath)) throw fail('请填写协议根路径，不要填写完整的模型操作路径', 'apiPath')
+    target.apiPaths = { [protocol]: apiPath }
+  }
+  const url = checked('connection.baseURL', () => kind === 'check' ? `${apiBase(target, protocol)}/models` : operationURL(target, protocol, operation, model))
+  const selection = kind === 'check'
+    ? { template: null, resolution: { mode: 'passthrough', message: '连接检查仅查询模型列表，不应用模板' }, warnings: [] }
+    : resolveSelection({ snapshot, connection, model, protocol, operation, templateMode, template, templateRef })
+  const selected = selection.template === null ? null : checked('template', () => structuredClone(selection.template))
+  if (selected) delete selected.archived
+  return {
+    kind,
+    connectionId: connection.id ?? null,
+    connectionName: connection.name ?? '',
+    model, protocol, operation, stream,
+    method: kind === 'check' ? 'GET' : 'POST',
+    url,
+    template: selected,
+    templateId: selected?.id ?? null,
+    revision: selected?.revision ?? null,
+    templateMode,
+    resolution: selection.resolution,
+    warnings: selection.warnings,
+  }
+}
+
+/** Generate a fresh sample for the exact protocol/model/stream/operation selection. */
+export function createTestSample(protocol, model, stream = false, operation) {
+  validateModel(model)
+  operation = chooseOperation(protocol, operation, stream)
+  const text = 'Reply with OK.'
+  if (protocol === 'gemini') {
+    const contents = [{ role: 'user', parts: [{ text }] }]
+    return operation === 'countTokens' ? { contents } : { contents, generationConfig: { maxOutputTokens: 128 } }
+  }
+  const messages = [{ role: 'user', content: text }]
+  if (protocol === 'anthropic' && operation === 'count_tokens') return { model, messages }
+  if (protocol === 'responses') return {
+    model, input: [{ role: 'user', content: [{ type: 'input_text', text }] }],
+    max_output_tokens: 128, store: false, prompt_cache_key: 'ua-pro-test-session', stream,
+  }
+  return { model, max_tokens: 128, messages, stream }
+}
+
+/** Return the original body after structural checks; never rewrite caller business fields. */
+export function validateTestSample(body, plan) {
+  if (!isObject(body)) throw fail('测试请求正文必须是 JSON 对象，不能是数组', 'request.body')
+  if (!isObject(plan)) throw fail('测试计划无效', 'plan')
+  validateProtocol(plan.protocol)
+  if (typeof body.model === 'string' && body.model !== plan.model) {
+    throw fail('请求正文模型与测试计划模型不一致，请重新生成样例或修改正文', 'request.body.model')
+  }
+  if (Object.hasOwn(body, 'stream')) {
+    if (typeof body.stream !== 'boolean') throw fail('请求正文 stream 必须是布尔值', 'request.body.stream')
+    if (body.stream !== plan.stream) throw fail('请求正文 stream 与测试计划不一致，请重新生成样例或修改正文', 'request.body.stream')
+  }
+  if (plan.operation === 'models') return body
+  if (['anthropic', 'chat-completions'].includes(plan.protocol) && !Array.isArray(body.messages)) {
+    throw fail('当前协议的测试正文需要 messages 数组', 'request.body.messages')
+  }
+  if (plan.protocol === 'responses' && typeof body.input !== 'string' && !Array.isArray(body.input)) {
+    throw fail('Responses 测试正文需要字符串或数组 input', 'request.body.input')
+  }
+  if (plan.protocol === 'gemini' && !Array.isArray(body.contents)) throw fail('Gemini 测试正文需要 contents 数组', 'request.body.contents')
+  return body
+}

package/package.json

@@ -1,6 +1,82 @@
 {
   "name": "opencode-claude-code-ua",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.3.6",
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "description": "UA PRO: versioned Codex and Claude compatibility templates, multi-protocol connections, previews and explicit upstream tests",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/1466109846/ua-pro.git"
+  },
+  "homepage": "https://github.com/1466109846/ua-pro#readme",
+  "bugs": {
+    "url": "https://github.com/1466109846/ua-pro/issues"
+  },
+  "type": "module",
+  "main": "./index.mjs",
+  "exports": {
+    ".": "./index.mjs",
+    "./server": "./index.mjs"
+  },
+  "files": [
+    "index.mjs",
+    "setup.mjs",
+    "lib",
+    "src",
+    "ui",
+    "assets",
+    "README.md",
+    "NOTICE.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "check": "node --check index.mjs && node --check src/plugin.mjs && node --check lib/parameters.mjs",
+    "setup": "node setup.mjs"
+  },
+  "engines": {
+    "node": ">=22"
+  },
+  "keywords": [
+    "opencode",
+    "opencode-plugin",
+    "magpie",
+    "anthropic",
+    "claude-code",
+    "user-agent"
+  ],
+  "magpie": {
+    "name": "UA PRO",
+    "icon": "data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZpZXdCb3g9IjAgMCA2NCA2NCIgcm9sZT0iaW1nIiBhcmlhLWxhYmVsPSJNYWdwaWUgQ2xhdWRlIENvZGUgVUEiPgogIDxyZWN0IHdpZHRoPSI2NCIgaGVpZ2h0PSI2NCIgcng9IjE0IiBmaWxsPSIjM2IyYjI0Ii8+CiAgPGcgZmlsbD0ibm9uZSIgc3Ryb2tlPSIjZjBiNzliIiBzdHJva2Utd2lkdGg9IjMuMiIgc3Ryb2tlLWxpbmVjYXA9InJvdW5kIj4KICAgIDxwYXRoIGQ9Ik0zMiAxMS41djkuMk0zMiA0My4zdjkuMk0xMS41IDMyaDkuMk00My4zIDMyaDkuMiIvPgogICAgPHBhdGggZD0iTTE3LjQgMTcuNGw2LjUgNi41TTQwLjEgNDAuMWw2LjUgNi41TTQ2LjYgMTcuNGwtNi41IDYuNU0yMy45IDQwLjFsLTYuNSA2LjUiLz4KICA8L2c+CiAgPGNpcmNsZSBjeD0iMzIiIGN5PSIzMiIgcj0iNyIgZmlsbD0iI2U2YTE4NCIvPgogIDxjaXJjbGUgY3g9IjMyIiBjeT0iMzIiIHI9IjIuNCIgZmlsbD0iIzNiMmIyNCIvPgo8L3N2Zz4=",
+    "summary": {
+      "zh": "Codex 与 Claude 客户端模板、版本化应用回退、四协议连接与转换测试。",
+      "en": "Versioned Codex and Claude templates, four-protocol connections, previews and explicit tests."
+    },
+    "maxConcurrency": 4,
+    "options": {
+      "userAgent": "claude-cli/2.1.316 (external, claude-vscode, agent-sdk/0.3.316)",
+      "headers": {
+        "accept": "application/json",
+        "anthropic-beta": "claude-code-20250219,context-1m-2025-08-07,interleaved-thinking-2025-05-14,thinking-token-count-2026-05-13,context-management-2025-06-27,prompt-caching-scope-2026-01-05,per-turn-control-2026-07-01,mid-conversation-tool-changes-2026-07-01,advanced-tool-use-2025-11-20,effort-2025-11-24,dangerous-tool-use-2026-09-03,afk-mode-2026-01-31",
+        "anthropic-dangerous-direct-browser-access": "true",
+        "anthropic-version": "2023-06-01",
+        "x-app": "cli",
+        "x-stainless-arch": "x64",
+        "x-stainless-lang": "js",
+        "x-stainless-os": "Windows",
+        "x-stainless-package-version": "0.128.0",
+        "x-stainless-retry-count": "0",
+        "x-stainless-runtime": "node",
+        "x-stainless-runtime-version": "v26.12.1",
+        "x-stainless-timeout": "300"
+      },
+      "parameters": {
+        "defaults": {},
+        "overrides": {},
+        "remove": []
+      }
+    }
+  }
+}

package/setup.mjs

@@ -0,0 +1,39 @@
+import { createProfileStore } from './src/store.mjs';
+import { startSetupServer } from './src/setup-server.mjs';
+import { resolveProfilePath, parseSetupArgs, openBrowser } from './src/runtime.mjs';
+import { createAccountManager } from './src/accounts.mjs';
+import { dirname, join } from 'node:path';
+import { createUAStore } from './src/ua-store.mjs';
+import { createUAService } from './src/ua-service.mjs';
+
+async function main() {
+  const args = parseSetupArgs(process.argv.slice(2));
+  if (args.help) {
+    console.log('UA PRO 设置\n\nnode setup.mjs [--config <绝对路径>] [--port <端口>] [--no-open]\n\n默认只监听 127.0.0.1，端口随机。MAGPIE_CLAUDE_PROFILE_FILE 可指定配置文件。\n远程宿主请使用 SSH 隧道。启动和保存配置不会访问上游；点击“检查连接”会读取模型列表，不发送聊天请求；账号页的刷新与签到会请求你填写的站点。');
+    return;
+  }
+  const store = createProfileStore(resolveProfilePath({ configPath: args.configPath }));
+  const accountManager = createAccountManager({ path: join(dirname(store.path), 'accounts.json') });
+  const uaStore = createUAStore(process.env.UA_PRO_FILE || join(dirname(store.path), 'ua-pro.json'));
+  const uaService = createUAService({ store: uaStore, legacyStore: store });
+  const session = await startSetupServer({ store, accountManager, uaService, port: args.port, finishOnSave: false });
+  console.log(`配置页面：${session.url}\n账号管理：${new URL('accounts', session.url).href}\n配置文件：${store.path}\n页面链接仅本次有效，请勿分享。`);
+  if (args.open && !await openBrowser(session.url)) console.log('未找到可用的浏览器，请手动打开上面的本地链接。');
+  const stop = () => { void session.close(); };
+  process.once('SIGINT', stop);
+  process.once('SIGTERM', stop);
+  const result = await session.finished;
+  process.removeListener('SIGINT', stop);
+  process.removeListener('SIGTERM', stop);
+  if (result.status === 'saved') console.log('配置已保存。上游地址、协议或模型列表改变后，请在 Magpie 重载插件。');
+  else if (result.status === 'managed') console.log('账号管理已完成，账号与额度记录已保存。');
+  else if (result.status === 'timeout') console.log('配置页面已超时；此前已保存的配置与账号记录保留。');
+  else console.log('配置已关闭；未提交的更改不保存，已保存的配置与账号记录保留。');
+  await new Promise((resolve) => setTimeout(resolve, 500));
+  await session.close();
+}
+
+main().catch(() => {
+  console.error('无法启动配置页面，请检查参数、配置文件格式与目录权限。运行 --help 查看用法。');
+  process.exitCode = 1;
+});

package/src/account-profile.mjs

@@ -0,0 +1,73 @@
+import { isDeepStrictEqual } from 'node:util';
+import { resolve } from 'node:path';
+const nativeWrites = new Map();
+const unscopedQueue = Symbol('native-account-writes');
+import { AUTH_MARKER, connectionProfile } from './connection.mjs';
+import { createDefaultProfile, mergeProfileSecrets, ProfileValidationError, redactProfile, VARIABLE_DEFINITIONS } from './profile.mjs';
+function requireNativeAuth(auth) {
+  if (auth?.type !== 'api' || typeof auth.key !== 'string' || !auth.key.trim() || auth.key.trim() === AUTH_MARKER) throw new ProfileValidationError({ 'upstream.apiKey': '请先选择已配置密钥的原生 API 账号' });
+}
+/** Session-only drafts; writes are confined to the injected native account slot. */
+export function createAccountProfileStore({ auth, savedProfile = null, provider = {}, defaults, path, readAuth, writeAuth }) {
+  requireNativeAuth(auth);
+  let currentAuth = structuredClone(auth);
+  let profile = connectionProfile(savedProfile, currentAuth, provider, defaults);
+  const queueKey = typeof path === 'string' ? (process.platform === 'win32' ? resolve(path).toLowerCase() : resolve(path)) : unscopedQueue;
+  async function load() { return structuredClone(profile); }
+  function getAuth() { return structuredClone(currentAuth); }
+  async function verifyCurrentAuth() {
+    if (!readAuth) return;
+    let latest;
+    try { latest = await readAuth(); }
+    catch { throw new Error('无法读取当前账号，请重新打开配置后重试'); }
+    if (!isDeepStrictEqual(latest, currentAuth)) throw new Error('当前账号已发生变化，请重新打开配置后重试');
+  }
+  async function prepareFromUi(raw, clearSecrets = []) {
+    await verifyCurrentAuth();
+    const draft = mergeProfileSecrets(raw, profile, clearSecrets);
+    requireNativeAuth({ type: 'api', key: draft.upstream.apiKey });
+    if (draft.upstream.apiKey !== profile.upstream.apiKey) {
+      // Changing the host key starts a new credential scope; old endpoint-specific extras cannot follow silently.
+      const old = profile.headers.extra.filter(item => item.enabled !== false);
+      const retained = draft.headers.extra.some(item => item.enabled !== false && old.some(entry => entry.name.toLowerCase() === item.name.toLowerCase() && entry.value === item.value));
+      if (retained) throw new ProfileValidationError({ 'headers.extra': 'API key 已改变，请移除旧凭据的附加请求头' });
+      const baseline = createDefaultProfile().headers;
+      const fields = {};
+      for (const [field, value] of Object.entries(draft.headers)) {
+        if (typeof value === 'string' && value.trim() && value !== baseline[field] && value === profile.headers[field]) {
+          fields[`headers.${field}`] = 'API key 已改变，请移除旧凭据的专用请求头';
+        }
+      }
+      if (Object.keys(fields).length) throw new ProfileValidationError(fields);
+      if (draft.upstream.authorizationValue && draft.upstream.authorizationValue === profile.upstream.authorizationValue) {
+        throw new ProfileValidationError({ 'upstream.authorizationValue': 'API key 已改变，请重新填写对应的 Authorization 或切换授权模式' });
+      }
+    }
+    return draft;
+  }
+  async function saveFromUi(raw, clearSecrets = []) {
+    const input = structuredClone(raw); const clears = structuredClone(clearSecrets);
+    const result = (nativeWrites.get(queueKey) ?? Promise.resolve()).then(async () => {
+      const nextProfile = await prepareFromUi(input, clears);
+      const nextAuth = structuredClone(currentAuth);
+      nextAuth.key = nextProfile.upstream.apiKey;
+      nextAuth.metadata = { ...nextAuth.metadata, baseURL: nextProfile.upstream.baseUrl, endpoint: nextProfile.upstream.baseUrl, claudeProfile: structuredClone(nextProfile) };
+      nextAuth.metadata.claudeProfile.upstream.apiKey = '';
+      await verifyCurrentAuth();
+      try { await writeAuth(structuredClone(nextAuth)); }
+      catch { throw new Error('账号配置保存失败，请重试；当前会话配置保留'); }
+      currentAuth = nextAuth; profile = nextProfile;
+      return structuredClone(profile);
+    });
+    const next = result.catch(() => {});
+    nativeWrites.set(queueKey, next);
+    next.finally(() => { if (nativeWrites.get(queueKey) === next) nativeWrites.delete(queueKey); });
+    return result;
+  }
+  async function publicInfo() {
+    return { profile: redactProfile(profile), configured: true,
+      secrets: { apiKey: Boolean(profile.upstream.apiKey), authorizationValue: Boolean(profile.upstream.authorizationValue) },
+      variables: VARIABLE_DEFINITIONS, storagePath: path };
+  }
+  return { path, load, prepareFromUi, saveFromUi, publicInfo, getAuth };
+}