ai-zero-token 2.0.3 → 2.0.5

package/dist/core/providers/http-client.js

@@ -1,5 +1,9 @@
 #!/usr/bin/env node
 import { spawn } from "node:child_process";
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { PassThrough, Readable } from "node:stream";
 import { loadSettings } from "../store/settings-store.js";
 const CURL_STATUS_MARKER = "\n__CURL_STATUS__:";
 const CURL_HEADERS_MARKER = "\n__CURL_HEADERS__:";
@@ -38,6 +42,9 @@ function logHttpTiming(params) {
     totalMs: params.timing.totalMs
   });
 }
+function isElectronRuntime() {
+  return typeof process.versions.electron === "string";
+}
 function normalizeHeaders(headers) {
   const normalized = {};
   headers.forEach((value, key) => {
@@ -62,6 +69,33 @@ function normalizeCurlHeaders(value) {
     })
   );
 }
+function parseCurlHeaderDump(raw) {
+  const blocks = raw.replace(/\r\n/g, "\n").split(/\n\n+/).map((block2) => block2.trim()).filter((block2) => /^HTTP\//i.test(block2));
+  const block = blocks[blocks.length - 1];
+  if (!block) {
+    return null;
+  }
+  const lines = block.split("\n");
+  const statusMatch = /^HTTP(?:\/\S+)?\s+(\d{3})/i.exec(lines[0]?.trim() ?? "");
+  const status = statusMatch ? Number.parseInt(statusMatch[1], 10) : NaN;
+  if (!Number.isFinite(status)) {
+    return null;
+  }
+  const headers = {};
+  for (const line of lines.slice(1)) {
+    const separator = line.indexOf(":");
+    if (separator <= 0) {
+      continue;
+    }
+    const key = line.slice(0, separator).trim().toLowerCase();
+    const value = line.slice(separator + 1).trim();
+    if (!key || !value) {
+      continue;
+    }
+    headers[key] = headers[key] ? `${headers[key]}, ${value}` : value;
+  }
+  return { status, headers };
+}
 async function runCurlRequest(init, params) {
   const requestId = params?.requestId ?? nextRequestId();
   const startedAt = performance.now();
@@ -89,13 +123,16 @@ async function runCurlRequest(init, params) {
   for (const [key, value] of Object.entries(init.headers ?? {})) {
     args.push("--header", `${key}: ${value}`);
   }
-  if (typeof init.body === "string") {
-    args.push("--data-raw", init.body);
+  const hasBody = typeof init.body === "string";
+  if (hasBody) {
+    args.push("--data-binary", "@-");
   }
   const child = spawn("curl", args, {
     env: process.env,
-    stdio: ["ignore", "pipe", "pipe"]
+    stdio: ["pipe", "pipe", "pipe"]
   });
+  child.stdin.on("error", () => void 0);
+  child.stdin.end(hasBody ? init.body : void 0);
   const phases = {
     spawnCurlMs: performance.now() - startedAt
   };
@@ -166,6 +203,133 @@ async function runCurlRequest(init, params) {
     headers
   };
 }
+async function waitForCurlHeaders(params) {
+  const startedAt = performance.now();
+  while (performance.now() - startedAt < params.timeoutMs) {
+    try {
+      const raw = await fs.readFile(params.headerPath, "utf8");
+      const parsed = parseCurlHeaderDump(raw);
+      if (parsed) {
+        return parsed;
+      }
+    } catch {
+    }
+    if (params.isClosed()) {
+      throw new Error(params.stderr().trim() || "curl stream \u8BF7\u6C42\u5728\u8FD4\u56DE\u54CD\u5E94\u5934\u524D\u7ED3\u675F\u3002");
+    }
+    await new Promise((resolve) => setTimeout(resolve, 25));
+  }
+  throw new Error("\u7B49\u5F85 curl stream \u54CD\u5E94\u5934\u8D85\u65F6\u3002");
+}
+async function runCurlStream(init, params) {
+  if (init.signal?.aborted) {
+    throw new Error("stream \u8BF7\u6C42\u5DF2\u53D6\u6D88\u3002");
+  }
+  const requestId = params?.requestId ?? nextRequestId();
+  const startedAt = performance.now();
+  const timeoutSeconds = typeof params?.timeoutMs === "number" && Number.isFinite(params.timeoutMs) && params.timeoutMs > 0 ? Math.max(1, Math.ceil(params.timeoutMs / 1e3)) : void 0;
+  const headerPath = path.join(os.tmpdir(), `azt-curl-headers-${process.pid}-${requestId}.txt`);
+  const args = [
+    "--silent",
+    "--show-error",
+    "--location",
+    "--no-buffer",
+    "--request",
+    init.method,
+    init.url,
+    "--dump-header",
+    headerPath
+  ];
+  if (typeof timeoutSeconds === "number") {
+    args.push("--connect-timeout", String(Math.min(timeoutSeconds, 10)));
+    args.push("--max-time", String(timeoutSeconds));
+  } else {
+    args.push("--connect-timeout", "10");
+  }
+  if (params?.proxy?.enabled && params.proxy.url.trim()) {
+    args.push("--proxy", params.proxy.url.trim());
+    if (params.proxy.noProxy.trim()) {
+      args.push("--noproxy", params.proxy.noProxy.trim());
+    }
+  }
+  for (const [key, value] of Object.entries(init.headers ?? {})) {
+    args.push("--header", `${key}: ${value}`);
+  }
+  const hasBody = typeof init.body === "string";
+  if (hasBody) {
+    args.push("--data-binary", "@-");
+  }
+  const child = spawn("curl", args, {
+    env: process.env,
+    stdio: ["pipe", "pipe", "pipe"]
+  });
+  child.stdin.on("error", () => void 0);
+  child.stdin.end(hasBody ? init.body : void 0);
+  const body = new PassThrough();
+  const phases = {
+    spawnCurlMs: performance.now() - startedAt
+  };
+  let stderr = "";
+  let closed = false;
+  let exitCode = 0;
+  const abort = () => {
+    child.kill("SIGTERM");
+  };
+  init.signal?.addEventListener("abort", abort, { once: true });
+  child.stdout.pipe(body);
+  child.stderr.setEncoding("utf8");
+  child.stderr.on("data", (chunk) => {
+    stderr += chunk;
+  });
+  child.on("error", (error) => {
+    closed = true;
+    stderr = stderr || error.message;
+    body.destroy(error);
+  });
+  child.on("close", (code) => {
+    closed = true;
+    exitCode = code ?? 1;
+    init.signal?.removeEventListener("abort", abort);
+    void fs.unlink(headerPath).catch(() => void 0);
+    if (exitCode !== 0 && !init.signal?.aborted) {
+      body.destroy(new Error(stderr.trim() || `curl stream \u8BF7\u6C42\u5931\u8D25\uFF0C\u9000\u51FA\u7801 ${exitCode}`));
+    }
+  });
+  let parsed;
+  try {
+    parsed = await waitForCurlHeaders({
+      headerPath,
+      isClosed: () => closed,
+      stderr: () => stderr,
+      timeoutMs: typeof params?.timeoutMs === "number" ? Math.min(params.timeoutMs, 3e4) : 3e4
+    });
+  } catch (error) {
+    child.kill("SIGTERM");
+    init.signal?.removeEventListener("abort", abort);
+    void fs.unlink(headerPath).catch(() => void 0);
+    body.destroy(error instanceof Error ? error : new Error(String(error)));
+    throw error;
+  }
+  phases.waitForHeadersMs = performance.now() - startedAt - phases.spawnCurlMs;
+  const timing = finalizeTiming(startedAt, phases);
+  logHttpTiming({
+    requestId,
+    method: init.method,
+    url: init.url,
+    status: parsed.status,
+    transport: "curl",
+    timing,
+    fallbackFrom: params?.fallbackFrom
+  });
+  return {
+    body: Readable.toWeb(body),
+    status: parsed.status,
+    transport: "curl",
+    timing,
+    requestId,
+    headers: parsed.headers
+  };
+}
 async function loadNetworkProxySettings() {
   try {
     const settings = await loadSettings();
@@ -236,6 +400,67 @@ async function requestText(init) {
     timeoutMs: remainingTimeoutMs
   });
 }
+async function requestStream(init) {
+  const requestId = nextRequestId();
+  const requestStartedAt = performance.now();
+  const proxy = init.ignoreProxy ? void 0 : init.proxyOverride ?? await loadNetworkProxySettings();
+  const useCurlOnly = process.env.OAUTH_DEMO_USE_CURL === "1" || isElectronRuntime();
+  const useConfiguredProxy = !!proxy?.enabled && !!proxy.url.trim();
+  const timeoutMs = init.timeoutMs;
+  if (!useCurlOnly && !useConfiguredProxy) {
+    const phases = {};
+    try {
+      const fetchStartedAt = performance.now();
+      const response = await fetch(init.url, {
+        method: init.method,
+        headers: init.headers,
+        body: init.body,
+        signal: init.signal
+      });
+      phases.waitForHeadersMs = performance.now() - fetchStartedAt;
+      const timing = finalizeTiming(requestStartedAt, phases);
+      logHttpTiming({
+        requestId,
+        method: init.method,
+        url: init.url,
+        status: response.status,
+        transport: "fetch",
+        timing
+      });
+      if (!response.body) {
+        throw new Error("fetch stream \u54CD\u5E94\u7F3A\u5C11 body\u3002");
+      }
+      return {
+        body: response.body,
+        status: response.status,
+        transport: "fetch",
+        timing,
+        requestId,
+        headers: normalizeHeaders(response.headers)
+      };
+    } catch (error) {
+      if (init.signal?.aborted) {
+        throw error;
+      }
+      const message = error instanceof Error ? error.message : String(error);
+      safeConsole("warn", "[http] fetch stream attempt failed", {
+        requestId,
+        method: init.method,
+        url: init.url,
+        elapsedMs: roundMs(performance.now() - requestStartedAt),
+        error: message
+      });
+    }
+  }
+  const remainingTimeoutMs = typeof timeoutMs === "number" && Number.isFinite(timeoutMs) && timeoutMs > 0 ? Math.max(1e3, timeoutMs - (performance.now() - requestStartedAt)) : void 0;
+  return runCurlStream(init, {
+    requestId,
+    fallbackFrom: useCurlOnly || useConfiguredProxy ? void 0 : "fetch",
+    proxy,
+    timeoutMs: remainingTimeoutMs
+  });
+}
 export {
+  requestStream,
   requestText
 };

package/dist/core/providers/openai-codex/chat.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import { DEFAULT_CODEX_MODEL } from "../../models/openai-codex-models.js";
-import { requestText } from "../http-client.js";
+import { requestStream, requestText } from "../http-client.js";
 const CODEX_RESPONSES_URL = "https://chatgpt.com/backend-api/codex/responses";
 const URL_KEY_RE = /(url|uri|href|download|preview|thumbnail|image|asset|file)/i;
 const REFERENCE_KEY_RE = /(image|asset|file|media|blob|artifact|download|preview|thumbnail)/i;
@@ -39,21 +39,65 @@ function parseOptionalText(value) {
 function parseUpstreamErrorBody(body) {
   try {
     const parsed = JSON.parse(body);
-    const error = parsed.error;
-    if (!error || typeof error !== "object") {
+    const record = asRecord(parsed.error);
+    if (!record) {
       return void 0;
     }
-    const record = error;
+    const eligiblePromo = asRecord(record.eligible_promo);
     return {
       message: typeof record.message === "string" ? record.message : void 0,
       type: typeof record.type === "string" ? record.type : void 0,
       code: typeof record.code === "string" ? record.code : void 0,
-      param: typeof record.param === "string" || record.param === null ? record.param : void 0
+      param: typeof record.param === "string" || record.param === null ? record.param : void 0,
+      planType: typeof record.plan_type === "string" ? record.plan_type : void 0,
+      resetsAt: typeof record.resets_at === "number" && Number.isFinite(record.resets_at) ? record.resets_at : void 0,
+      resetsInSeconds: typeof record.resets_in_seconds === "number" && Number.isFinite(record.resets_in_seconds) ? record.resets_in_seconds : void 0,
+      promoCampaignId: typeof eligiblePromo?.campaign_id === "string" ? eligiblePromo.campaign_id : void 0,
+      promoMessage: typeof eligiblePromo?.message === "string" ? eligiblePromo.message : void 0
     };
   } catch {
     return void 0;
   }
 }
+function buildCodexRequestHeaders(profile) {
+  return {
+    Accept: "text/event-stream",
+    "Content-Type": "application/json",
+    Authorization: `Bearer ${profile.access}`,
+    "ChatGPT-Account-Id": profile.accountId,
+    "OpenAI-Beta": "responses=experimental",
+    Originator: "pi",
+    "User-Agent": "pi (bun demo)"
+  };
+}
+function createCodexUpstreamError(status, body, transport, quota, requestId) {
+  const upstreamError = parseUpstreamErrorBody(body);
+  const error = new Error(`\u8C03\u7528 Responses API \u5931\u8D25: HTTP ${status} via ${transport} ${body}`);
+  error.quota = quota ?? createUsageLimitQuotaSnapshot(status, upstreamError, requestId);
+  error.upstreamStatus = status;
+  error.upstreamErrorCode = upstreamError?.code;
+  error.upstreamErrorType = upstreamError?.type;
+  error.upstreamErrorMessage = upstreamError?.message;
+  return error;
+}
+function createUsageLimitQuotaSnapshot(status, upstreamError, requestId) {
+  const errorKind = `${upstreamError?.type ?? ""} ${upstreamError?.code ?? ""}`.toLowerCase();
+  if (status !== 429 && !errorKind.includes("usage_limit_reached")) {
+    return void 0;
+  }
+  return {
+    capturedAt: Date.now(),
+    sourceRequestId: requestId,
+    planType: upstreamError?.planType,
+    primaryUsedPercent: 100,
+    primaryResetAt: upstreamError?.resetsAt,
+    primaryResetAfterSeconds: upstreamError?.resetsInSeconds,
+    creditsHasCredits: false,
+    creditsBalance: "0",
+    promoCampaignId: upstreamError?.promoCampaignId,
+    promoMessage: upstreamError?.promoMessage
+  };
+}
 function extractCodexQuotaSnapshot(headers, requestId) {
   const activeLimit = parseOptionalText(headers["x-codex-active-limit"]);
   const planType = parseOptionalText(headers["x-codex-plan-type"]);
@@ -138,6 +182,80 @@ function extractOutputText(payload) {
   }
   return "";
 }
+function asRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function optionalString(value) {
+  return typeof value === "string" && value ? value : void 0;
+}
+function stringifyToolArguments(value) {
+  if (typeof value === "string") {
+    return value;
+  }
+  if (typeof value === "undefined" || value === null) {
+    return "";
+  }
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+}
+function upsertFunctionCall(items, value) {
+  const record = asRecord(value);
+  if (!record || record.type !== "function_call") {
+    return;
+  }
+  const name = optionalString(record.name);
+  const id = optionalString(record.call_id) ?? optionalString(record.id);
+  if (!name || !id) {
+    return;
+  }
+  items.set(id, {
+    id,
+    type: "function",
+    function: {
+      name,
+      arguments: stringifyToolArguments(record.arguments)
+    }
+  });
+}
+function appendFunctionCallArgumentsDelta(items, argumentDeltas, event) {
+  if (event.type !== "response.function_call_arguments.delta") {
+    return;
+  }
+  const itemId = optionalString(event.item_id) ?? optionalString(event.call_id);
+  if (!itemId || typeof event.delta !== "string") {
+    return;
+  }
+  argumentDeltas.set(itemId, `${argumentDeltas.get(itemId) ?? ""}${event.delta}`);
+  const existing = items.get(itemId);
+  if (existing) {
+    existing.function.arguments = argumentDeltas.get(itemId) ?? existing.function.arguments;
+  }
+}
+function extractToolCalls(responsePayload, events) {
+  const calls = /* @__PURE__ */ new Map();
+  const argumentDeltas = /* @__PURE__ */ new Map();
+  const response = asRecord(responsePayload);
+  const output = Array.isArray(response?.output) ? response.output : [];
+  for (const item of output) {
+    upsertFunctionCall(calls, item);
+  }
+  for (const event of events) {
+    if (event.type === "response.output_item.added" || event.type === "response.output_item.done") {
+      upsertFunctionCall(calls, event.item);
+    }
+    appendFunctionCallArgumentsDelta(calls, argumentDeltas, event);
+  }
+  for (const [id, argumentsDelta] of argumentDeltas) {
+    const existing = calls.get(id);
+    if (existing && !existing.function.arguments) {
+      existing.function.arguments = argumentsDelta;
+    }
+  }
+  return Array.from(calls.values()).filter((call) => call.function.name);
+}
 function parseSseEvents(body) {
   const events = [];
   for (const chunk of body.split("\n\n")) {
@@ -249,6 +367,7 @@ function extractCodexText(body, requestBody) {
     }
   }
   const completedText = extractOutputText(responsePayload);
+  const toolCalls = extractToolCalls(responsePayload, events);
   const artifacts = [
     ...collectArtifactCandidates(responsePayload, "response"),
     ...collectArtifactCandidates(events, "event")
@@ -256,6 +375,7 @@ function extractCodexText(body, requestBody) {
   if (completedText) {
     return {
       text: completedText,
+      toolCalls,
       raw: {
         request: requestBody,
         response: responsePayload ?? null,
@@ -266,6 +386,7 @@ function extractCodexText(body, requestBody) {
   }
   return {
     text: accumulated.trim(),
+    toolCalls,
     raw: {
       request: requestBody,
       response: responsePayload ?? null,
@@ -285,34 +406,50 @@ async function askOpenAICodex(params) {
   const response = await requestText({
     method: "POST",
     url: CODEX_RESPONSES_URL,
-    headers: {
-      Accept: "text/event-stream",
-      "Content-Type": "application/json",
-      Authorization: `Bearer ${params.profile.access}`,
-      "ChatGPT-Account-Id": params.profile.accountId,
-      "OpenAI-Beta": "responses=experimental",
-      Originator: "pi",
-      "User-Agent": "pi (bun demo)"
-    },
+    headers: buildCodexRequestHeaders(params.profile),
     body: JSON.stringify(requestBody)
   });
   const quota = extractCodexQuotaSnapshot(response.headers, response.requestId);
   if (response.status < 200 || response.status >= 300) {
-    const upstreamError = parseUpstreamErrorBody(response.body);
-    const error = new Error(`\u8C03\u7528 Responses API \u5931\u8D25: HTTP ${response.status} via ${response.transport} ${response.body}`);
-    error.quota = quota;
-    error.upstreamStatus = response.status;
-    error.upstreamErrorCode = upstreamError?.code;
-    error.upstreamErrorType = upstreamError?.type;
-    error.upstreamErrorMessage = upstreamError?.message;
-    throw error;
+    throw createCodexUpstreamError(response.status, response.body, response.transport, quota, response.requestId);
   }
   return {
     ...extractCodexText(response.body, requestBody),
     quota
   };
 }
+async function streamOpenAICodex(params) {
+  const requestBody = params.passthroughBody ? { ...params.bodyOverride ?? {} } : {
+    ...buildDefaultRequestBody(params),
+    ...params.bodyOverride ?? {}
+  };
+  if (!params.passthroughBody && typeof requestBody.input === "undefined") {
+    throw new Error("Codex \u8BF7\u6C42\u7F3A\u5C11 input\u3002\u8BF7\u63D0\u4F9B prompt \u6216\u5728\u5B9E\u9A8C\u8BF7\u6C42\u4F53\u91CC\u663E\u5F0F\u4F20\u5165 input\u3002");
+  }
+  const response = await requestStream({
+    method: "POST",
+    url: CODEX_RESPONSES_URL,
+    headers: buildCodexRequestHeaders(params.profile),
+    body: JSON.stringify(requestBody),
+    signal: params.signal
+  });
+  const headers = response.headers;
+  const requestId = headers["x-request-id"] ?? response.requestId;
+  const quota = extractCodexQuotaSnapshot(headers, requestId);
+  if (response.status < 200 || response.status >= 300) {
+    const body = await new Response(response.body).text();
+    throw createCodexUpstreamError(response.status, body, response.transport, quota, requestId);
+  }
+  return {
+    body: response.body,
+    headers,
+    quota,
+    requestId,
+    status: response.status
+  };
+}
 export {
   askOpenAICodex,
-  extractCodexQuotaSnapshot
+  extractCodexQuotaSnapshot,
+  streamOpenAICodex
 };

package/dist/core/services/auth-service.js

@@ -15,8 +15,10 @@ import {
 } from "../providers/openai-codex/oauth.js";
 import { askOpenAICodex } from "../providers/openai-codex/chat.js";
 import {
+  applyGatewayToCodexProviderConfig,
   applyProfileToCodexAuth,
-  getCodexAuthStatus
+  getCodexAuthStatus,
+  removeGatewayFromCodexProviderConfig
 } from "../store/codex-auth-store.js";
 import {
   exportProfilesToJson,
@@ -209,7 +211,8 @@ class AuthService {
   }
   async maybeAutoSwitchProfile(profile, provider) {
     const settings = await this.configService.getSettings();
-    if (!settings.autoSwitch.enabled || !this.isQuotaExhausted(profile)) {
+    const excludedProfileIds = new Set(settings.autoSwitch.excludedProfileIds);
+    if (!settings.autoSwitch.enabled || excludedProfileIds.has(profile.profileId) || !this.isQuotaExhausted(profile)) {
       return profile;
     }
     const [profiles, codexStatus] = await Promise.all([
@@ -222,7 +225,7 @@ class AuthService {
       profile: item,
       index,
       distance: currentIndex >= 0 ? (index - currentIndex + profiles.length) % profiles.length : index + 1
-    })).filter((item) => item.profile.provider === provider && item.profile.profileId !== profile.profileId).filter((item) => this.hasKnownAvailableQuota(item.profile)).sort((left, right) => {
+    })).filter((item) => item.profile.provider === provider && item.profile.profileId !== profile.profileId).filter((item) => !excludedProfileIds.has(item.profile.profileId)).filter((item) => this.hasKnownAvailableQuota(item.profile)).sort((left, right) => {
       const leftCodexConflict = codexAccountId && left.profile.accountId === codexAccountId ? 1 : 0;
       const rightCodexConflict = codexAccountId && right.profile.accountId === codexAccountId ? 1 : 0;
       const codexDiff = leftCodexConflict - rightCodexConflict;
@@ -326,6 +329,12 @@ class AuthService {
     const profile = await this.requireFreshProfileWithIdToken(profileId, provider);
     return applyProfileToCodexAuth(profile);
   }
+  async applyGatewayToCodexProvider(params) {
+    return applyGatewayToCodexProviderConfig(params);
+  }
+  async removeGatewayFromCodexProvider(params) {
+    return removeGatewayFromCodexProviderConfig(params);
+  }
   async getActiveProfile(provider = "openai-codex") {
     const profile = await getActiveProfile();
     if (!profile || profile.provider !== provider) {
@@ -517,9 +526,9 @@ class AuthService {
   async recordProfileRequestFailure(profileId, error, quota, provider = "openai-codex", options) {
     const authStatus = this.createAuthStatusFromError(error);
     if (!quota && !authStatus) {
-      return;
+      return null;
     }
-    await this.applyProfileRuntimeUpdate(
+    return this.applyProfileRuntimeUpdate(
       profileId,
       provider,
       (profile) => ({

package/dist/core/services/chat-service.js

@@ -23,6 +23,7 @@ class ChatService {
         provider,
         model,
         text: result.text,
+        toolCalls: result.toolCalls,
         raw: result.raw,
         artifacts: result.artifacts
       };

package/dist/core/services/config-service.js

@@ -31,14 +31,22 @@ function normalizeNetworkProxy(settings, params) {
     noProxy
   };
 }
+function normalizeProfileIdList(value, fallback = []) {
+  if (!value) {
+    return fallback;
+  }
+  return Array.from(
+    new Set(
+      value.map((item) => item.trim()).filter(Boolean)
+    )
+  );
+}
 class ConfigService {
   async getSettings() {
     return this.ensureSettings();
   }
   async ensureSettings() {
-    const settings = await loadSettings();
-    await saveSettings(settings);
-    return settings;
+    return loadSettings();
   }
   async getDefaultProvider() {
     const settings = await this.getSettings();
@@ -81,7 +89,8 @@ class ConfigService {
     const next = {
       ...settings,
       autoSwitch: {
-        enabled: params.enabled
+        enabled: params.enabled ?? settings.autoSwitch.enabled,
+        excludedProfileIds: normalizeProfileIdList(params.excludedProfileIds, settings.autoSwitch.excludedProfileIds)
       }
     };
     await saveSettings(next);
@@ -138,7 +147,8 @@ class ConfigService {
       next = {
         ...next,
         autoSwitch: {
-          enabled: params.autoSwitch.enabled
+          enabled: params.autoSwitch.enabled ?? next.autoSwitch.enabled,
+          excludedProfileIds: normalizeProfileIdList(params.autoSwitch.excludedProfileIds, next.autoSwitch.excludedProfileIds)
         }
       };
     }