hermes-web-ui 0.4.1 → 0.4.2

package/dist/server/index.js

@@ -40045,7 +40045,19 @@ function resolveHermesBin() {
   return "hermes";
 }
 var HERMES_BIN2 = resolveHermesBin();
-async function listSessions(source, limit) {
+function parseSessionExport(stdout) {
+  const lines = stdout.trim().split("\n").filter(Boolean);
+  const sessions2 = [];
+  for (const line of lines) {
+    try {
+      const raw = JSON.parse(line);
+      sessions2.push(raw);
+    } catch {
+    }
+  }
+  return sessions2;
+}
+async function exportSessionsRaw(source) {
   const args2 = ["sessions", "export", "-"];
   if (source) args2.push("--source", source);
   try {
@@ -40055,53 +40067,52 @@ async function listSessions(source, limit) {
       timeout: 3e4,
       ...execOpts
     });
-    const lines = stdout.trim().split("\n").filter(Boolean);
-    const sessions2 = [];
-    for (const line of lines) {
-      try {
-        const raw = JSON.parse(line);
-        let title = raw.title;
-        if (!title && raw.messages) {
-          const firstUser = raw.messages.find((m) => m.role === "user");
-          if (firstUser?.content) {
-            const t = String(firstUser.content).slice(0, 40);
-            title = t + (String(firstUser.content).length > 40 ? "..." : "");
-          }
-        }
-        sessions2.push({
-          id: raw.id,
-          source: raw.source,
-          user_id: raw.user_id,
-          model: raw.model,
-          title,
-          started_at: raw.started_at,
-          ended_at: raw.ended_at,
-          end_reason: raw.end_reason,
-          message_count: raw.message_count,
-          tool_call_count: raw.tool_call_count,
-          input_tokens: raw.input_tokens,
-          output_tokens: raw.output_tokens,
-          cache_read_tokens: raw.cache_read_tokens || 0,
-          cache_write_tokens: raw.cache_write_tokens || 0,
-          reasoning_tokens: raw.reasoning_tokens || 0,
-          billing_provider: raw.billing_provider,
-          estimated_cost_usd: raw.estimated_cost_usd,
-          actual_cost_usd: raw.actual_cost_usd ?? null,
-          cost_status: raw.cost_status || ""
-        });
-      } catch {
-      }
-    }
-    sessions2.sort((a, b) => b.started_at - a.started_at);
-    if (limit && limit > 0) {
-      return sessions2.slice(0, limit);
-    }
-    return sessions2;
+    return parseSessionExport(stdout);
   } catch (err) {
     logger.error(err, "Hermes CLI: sessions export failed");
     throw new Error(`Failed to list sessions: ${err.message}`);
   }
 }
+async function listSessions(source, limit) {
+  const raws = await exportSessionsRaw(source);
+  const sessions2 = [];
+  for (const raw of raws) {
+    let title = raw.title;
+    if (!title && raw.messages) {
+      const firstUser = raw.messages.find((m) => m.role === "user");
+      if (firstUser?.content) {
+        const t = String(firstUser.content).slice(0, 40);
+        title = t + (String(firstUser.content).length > 40 ? "..." : "");
+      }
+    }
+    sessions2.push({
+      id: raw.id,
+      source: raw.source,
+      user_id: raw.user_id,
+      model: raw.model,
+      title,
+      started_at: raw.started_at,
+      ended_at: raw.ended_at,
+      end_reason: raw.end_reason,
+      message_count: raw.message_count,
+      tool_call_count: raw.tool_call_count,
+      input_tokens: raw.input_tokens,
+      output_tokens: raw.output_tokens,
+      cache_read_tokens: raw.cache_read_tokens || 0,
+      cache_write_tokens: raw.cache_write_tokens || 0,
+      reasoning_tokens: raw.reasoning_tokens || 0,
+      billing_provider: raw.billing_provider,
+      estimated_cost_usd: raw.estimated_cost_usd,
+      actual_cost_usd: raw.actual_cost_usd ?? null,
+      cost_status: raw.cost_status || ""
+    });
+  }
+  sessions2.sort((a, b) => b.started_at - a.started_at);
+  if (limit && limit > 0) {
+    return sessions2.slice(0, limit);
+  }
+  return sessions2;
+}
 async function getSession(id) {
   const args2 = ["sessions", "export", "-", "--session-id", id];
   try {
@@ -40110,10 +40121,9 @@ async function getSession(id) {
       timeout: 3e4,
       ...execOpts
     });
-    const lines = stdout.trim().split("\n").filter(Boolean);
-    if (lines.length === 0) return null;
-    if (!lines[0].startsWith("{")) return null;
-    const raw = JSON.parse(lines[0]);
+    const raws = parseSessionExport(stdout);
+    if (raws.length === 0) return null;
+    const raw = raws[0];
     return {
       id: raw.id,
       source: raw.source,
@@ -40410,7 +40420,7 @@ async function importProfile(archivePath, name) {
 }
 
 // packages/server/src/controllers/health.ts
-var LOCAL_VERSION = true ? "0.4.1" : (() => {
+var LOCAL_VERSION = true ? "0.4.2" : (() => {
   try {
     const { readFileSync: readFileSync8 } = null;
     const { resolve: resolve8 } = null;
@@ -40676,6 +40686,309 @@ async function handleUpdate(ctx) {
 var updateRoutes = new router_default();
 updateRoutes.post("/api/hermes/update", handleUpdate);
 
+// packages/server/src/services/hermes/conversations.ts
+var LINEAGE_TOLERANCE_SECONDS = 3;
+var LIVE_WINDOW_SECONDS = 300;
+var EXPORT_CACHE_TTL_MS = 3e4;
+var DEFAULT_CONVERSATION_LIMIT = 200;
+var SYNTHETIC_USER_PREFIXES = [
+  "[system:",
+  "you've reached the maximum number of tool-calling iterations allowed.",
+  "you have reached the maximum number of tool-calling iterations allowed."
+];
+var exportCache = /* @__PURE__ */ new Map();
+function cacheKey(source) {
+  return source || "__all__";
+}
+function safeText(value) {
+  if (typeof value === "string") return value;
+  if (typeof value === "number" || typeof value === "boolean") return String(value);
+  return "";
+}
+function textFromContent(value) {
+  if (typeof value === "string") return value;
+  if (typeof value === "number" || typeof value === "boolean") return String(value);
+  if (Array.isArray(value)) {
+    return value.map((item) => textFromContent(item).trim()).filter(Boolean).join("\n");
+  }
+  if (!value || typeof value !== "object") return "";
+  const record = value;
+  const directKeys = ["text", "content", "value"];
+  for (const key of directKeys) {
+    const direct = record[key];
+    if (typeof direct === "string") return direct;
+    if (Array.isArray(direct)) {
+      const nested = textFromContent(direct);
+      if (nested) return nested;
+    }
+  }
+  const nestedKeys = ["parts", "children", "items"];
+  for (const key of nestedKeys) {
+    if (Array.isArray(record[key])) {
+      const nested = textFromContent(record[key]);
+      if (nested) return nested;
+    }
+  }
+  const flattened = Object.values(record).map((entry) => textFromContent(entry).trim()).filter(Boolean).join("\n");
+  if (flattened) return flattened;
+  try {
+    return JSON.stringify(record);
+  } catch {
+    return "";
+  }
+}
+function normalizeText(value) {
+  return textFromContent(value).replace(/\s+/g, " ").trim().toLowerCase();
+}
+function excerpt(value, width = 80) {
+  const text = textFromContent(value).replace(/\s+/g, " ").trim();
+  if (!text) return "";
+  return text.length > width ? `${text.slice(0, width)}\u2026` : text;
+}
+function isSyntheticUserText(content) {
+  const text = normalizeText(content);
+  return SYNTHETIC_USER_PREFIXES.some((prefix) => text.startsWith(prefix));
+}
+function visibleHumanMessage(message2) {
+  const role = safeText(message2.role);
+  const content = textFromContent(message2.content).trim();
+  if (!content) return false;
+  if (role !== "user" && role !== "assistant") return false;
+  if (role === "user" && isSyntheticUserText(content)) return false;
+  return true;
+}
+function firstVisibleHumanText(messages) {
+  const firstVisible = messages.find(visibleHumanMessage);
+  return firstVisible ? textFromContent(firstVisible.content).trim() : "";
+}
+function maxMessageTimestamp(messages) {
+  return messages.reduce((max, message2) => {
+    const timestamp2 = Number(message2.timestamp || 0);
+    return Number.isFinite(timestamp2) && timestamp2 > max ? timestamp2 : max;
+  }, 0);
+}
+function enrichSession(session, nowSeconds) {
+  const messages = Array.isArray(session.messages) ? session.messages : [];
+  const preview = excerpt(firstVisibleHumanText(messages));
+  const lastActive = maxMessageTimestamp(messages) || Number(session.ended_at || session.started_at || 0);
+  const endedAt = session.ended_at ?? null;
+  return {
+    ...session,
+    parent_session_id: session.parent_session_id ?? null,
+    preview,
+    last_active: lastActive,
+    is_active: endedAt == null && nowSeconds - lastActive <= LIVE_WINDOW_SECONDS
+  };
+}
+function sortByRecency(items) {
+  return [...items].sort((a, b) => {
+    if (b.last_active !== a.last_active) return b.last_active - a.last_active;
+    if (b.started_at !== a.started_at) return b.started_at - a.started_at;
+    return a.id.localeCompare(b.id);
+  });
+}
+function timingMatchesParent(parent, child) {
+  if (!parent || !child || parent.ended_at == null) return false;
+  return Math.abs(Number(child.started_at || 0) - Number(parent.ended_at || 0)) <= LINEAGE_TOLERANCE_SECONDS;
+}
+function isBranchRoot(session, byId) {
+  if (!session?.parent_session_id) return false;
+  const parent = byId.get(session.parent_session_id);
+  return !!parent && parent.end_reason === "branched" && timingMatchesParent(parent, session);
+}
+function isVisibleRoot(session, byId) {
+  if (!session || session.source === "tool") return false;
+  return session.parent_session_id == null || isBranchRoot(session, byId);
+}
+function continuationCandidates(parent, byId, childrenByParent) {
+  const childIds = childrenByParent.get(parent.id) || [];
+  return childIds.map((childId) => byId.get(childId)).filter((child) => !!child).filter((child) => child.source !== "tool").filter((child) => child.source === parent.source).filter((child) => timingMatchesParent(parent, child)).sort((a, b) => {
+    const aDelta = Math.abs(Number(a.started_at || 0) - Number(parent.ended_at || 0));
+    const bDelta = Math.abs(Number(b.started_at || 0) - Number(parent.ended_at || 0));
+    if (aDelta !== bDelta) return aDelta - bDelta;
+    return a.id.localeCompare(b.id);
+  });
+}
+function nextContinuationChild(parent, byId, childrenByParent) {
+  if (parent.end_reason !== "compression") return null;
+  const candidates = continuationCandidates(parent, byId, childrenByParent);
+  if (candidates.length === 1) return candidates[0];
+  const exactPreviewMatches = candidates.filter((child) => {
+    const childPreview = normalizeText(child.preview);
+    const parentPreview = normalizeText(parent.preview);
+    return !!childPreview && childPreview === parentPreview;
+  });
+  if (exactPreviewMatches.length === 1) return exactPreviewMatches[0];
+  return null;
+}
+function collectConversationChain(rootId, byId, childrenByParent) {
+  const chain = [];
+  const seen = /* @__PURE__ */ new Set();
+  let current = byId.get(rootId) || null;
+  while (current && !seen.has(current.id)) {
+    chain.push(current);
+    seen.add(current.id);
+    current = nextContinuationChild(current, byId, childrenByParent);
+  }
+  return chain;
+}
+function sessionMessages(session) {
+  return Array.isArray(session.messages) ? session.messages : [];
+}
+function normalizeVisibleMessage(message2, session, index) {
+  if (!visibleHumanMessage(message2)) return null;
+  const role = safeText(message2.role);
+  const content = textFromContent(message2.content).trim();
+  if (role !== "user" && role !== "assistant") return null;
+  if (!content) return null;
+  const rawTimestamp = Number(message2.timestamp);
+  const timestamp2 = Number.isFinite(rawTimestamp) && rawTimestamp > 0 ? rawTimestamp : Number(session.ended_at || session.started_at || 0);
+  const id = message2.id ?? `${session.id}:${index}:${timestamp2}`;
+  return {
+    id,
+    session_id: safeText(message2.session_id || session.id),
+    role,
+    content,
+    timestamp: timestamp2
+  };
+}
+function visibleMessagesForSessions(sessions2) {
+  return sessions2.flatMap((session) => sessionMessages(session).map((message2, index) => normalizeVisibleMessage({ ...message2, session_id: safeText(message2.session_id || session.id) }, session, index))).filter((message2) => !!message2).sort((a, b) => {
+    if (a.timestamp !== b.timestamp) return a.timestamp - b.timestamp;
+    return String(a.id).localeCompare(String(b.id));
+  });
+}
+function hasVisibleHumanMessages(sessions2) {
+  return visibleMessagesForSessions(sessions2).length > 0;
+}
+function toSummary(session) {
+  return {
+    id: session.id,
+    source: safeText(session.source),
+    model: safeText(session.model),
+    title: session.title ?? null,
+    started_at: Number(session.started_at || 0),
+    ended_at: session.ended_at ?? null,
+    last_active: session.last_active,
+    message_count: Number(session.message_count || 0),
+    tool_call_count: Number(session.tool_call_count || 0),
+    input_tokens: Number(session.input_tokens || 0),
+    output_tokens: Number(session.output_tokens || 0),
+    cache_read_tokens: Number(session.cache_read_tokens || 0),
+    cache_write_tokens: Number(session.cache_write_tokens || 0),
+    reasoning_tokens: Number(session.reasoning_tokens || 0),
+    billing_provider: session.billing_provider ?? null,
+    estimated_cost_usd: Number(session.estimated_cost_usd || 0),
+    actual_cost_usd: session.actual_cost_usd ?? null,
+    cost_status: safeText(session.cost_status),
+    preview: session.preview,
+    is_active: session.is_active,
+    thread_session_count: 1
+  };
+}
+function aggregateSummary(rootId, byId, childrenByParent) {
+  const chain = collectConversationChain(rootId, byId, childrenByParent);
+  if (!chain.length || !hasVisibleHumanMessages(chain)) return null;
+  const root = chain[0];
+  const last = chain[chain.length - 1];
+  const title = root.title || excerpt(firstVisibleHumanText(chain.flatMap(sessionMessages)), 72) || null;
+  const preview = root.preview || excerpt(firstVisibleHumanText(chain.flatMap(sessionMessages)));
+  const costStatuses = Array.from(new Set(chain.map((session) => safeText(session.cost_status)).filter(Boolean)));
+  return {
+    ...toSummary(root),
+    title,
+    preview,
+    model: safeText(last?.model || root.model),
+    ended_at: last?.ended_at ?? null,
+    last_active: Math.max(...chain.map((session) => session.last_active)),
+    is_active: chain.some((session) => session.is_active),
+    billing_provider: last?.billing_provider ?? root.billing_provider ?? null,
+    cost_status: costStatuses.length === 1 ? costStatuses[0] : "mixed",
+    thread_session_count: chain.length,
+    message_count: chain.reduce((sum, session) => sum + Number(session.message_count || 0), 0),
+    tool_call_count: chain.reduce((sum, session) => sum + Number(session.tool_call_count || 0), 0),
+    input_tokens: chain.reduce((sum, session) => sum + Number(session.input_tokens || 0), 0),
+    output_tokens: chain.reduce((sum, session) => sum + Number(session.output_tokens || 0), 0),
+    cache_read_tokens: chain.reduce((sum, session) => sum + Number(session.cache_read_tokens || 0), 0),
+    cache_write_tokens: chain.reduce((sum, session) => sum + Number(session.cache_write_tokens || 0), 0),
+    reasoning_tokens: chain.reduce((sum, session) => sum + Number(session.reasoning_tokens || 0), 0),
+    estimated_cost_usd: chain.reduce((sum, session) => sum + Number(session.estimated_cost_usd || 0), 0),
+    actual_cost_usd: chain.reduce((sum, session) => {
+      const actual = session.actual_cost_usd;
+      if (actual == null) return sum;
+      return (sum || 0) + Number(actual);
+    }, null)
+  };
+}
+async function loadSessions(source) {
+  const key = cacheKey(source);
+  const nowMs = Date.now();
+  const cached = exportCache.get(key);
+  const raws = cached && cached.expires_at_ms > nowMs ? cached.sessions : await exportSessionsRaw(source);
+  if (!cached || cached.expires_at_ms <= nowMs) {
+    exportCache.set(key, {
+      expires_at_ms: nowMs + EXPORT_CACHE_TTL_MS,
+      sessions: raws
+    });
+  }
+  const nowSeconds = nowMs / 1e3;
+  return raws.map((raw) => enrichSession(raw, nowSeconds));
+}
+async function listConversationSummaries(options = {}) {
+  const humanOnly = options.humanOnly !== false;
+  const limit = options.limit && options.limit > 0 ? options.limit : DEFAULT_CONVERSATION_LIMIT;
+  const sessions2 = await loadSessions(options.source);
+  const byId = new Map(sessions2.map((session) => [session.id, session]));
+  const childrenByParent = /* @__PURE__ */ new Map();
+  for (const session of sessions2) {
+    const key = session.parent_session_id ?? null;
+    const siblings = childrenByParent.get(key) || [];
+    siblings.push(session.id);
+    childrenByParent.set(key, siblings);
+  }
+  if (!humanOnly) {
+    return sortByRecency(
+      sessions2.filter((session) => session.source !== "tool").map(toSummary)
+    ).slice(0, limit);
+  }
+  const summaries = sessions2.filter((session) => isVisibleRoot(session, byId)).map((session) => aggregateSummary(session.id, byId, childrenByParent)).filter((summary) => !!summary);
+  return sortByRecency(summaries).slice(0, limit);
+}
+async function getConversationDetail(sessionId, options = {}) {
+  const humanOnly = options.humanOnly !== false;
+  const sessions2 = await loadSessions(options.source);
+  const byId = new Map(sessions2.map((session) => [session.id, session]));
+  const childrenByParent = /* @__PURE__ */ new Map();
+  for (const session of sessions2) {
+    const key = session.parent_session_id ?? null;
+    const siblings = childrenByParent.get(key) || [];
+    siblings.push(session.id);
+    childrenByParent.set(key, siblings);
+  }
+  if (!humanOnly) {
+    const session = byId.get(sessionId);
+    if (!session || session.source === "tool") return null;
+    const messages2 = visibleMessagesForSessions([session]);
+    return {
+      session_id: sessionId,
+      messages: messages2,
+      visible_count: messages2.length,
+      thread_session_count: 1
+    };
+  }
+  const root = byId.get(sessionId);
+  if (!isVisibleRoot(root, byId)) return null;
+  const chain = collectConversationChain(sessionId, byId, childrenByParent);
+  const messages = visibleMessagesForSessions(chain);
+  if (!messages.length) return null;
+  return {
+    session_id: sessionId,
+    messages,
+    visible_count: messages.length,
+    thread_session_count: chain.length
+  };
+}
+
 // packages/server/src/services/hermes/sessions-db.ts
 init_hermes_profile();
 var SQLITE_AVAILABLE = (() => {
@@ -40787,6 +41100,33 @@ async function listSessionSummaries(source, limit = 2e3) {
 
 // packages/server/src/controllers/hermes/sessions.ts
 init_logger();
+function parseHumanOnly(value) {
+  if (typeof value !== "string") return true;
+  return value !== "false" && value !== "0";
+}
+function parseLimit(value) {
+  if (typeof value !== "string") return void 0;
+  const parsed = parseInt(value, 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : void 0;
+}
+async function listConversations(ctx) {
+  const source = ctx.query.source || void 0;
+  const humanOnly = parseHumanOnly(ctx.query.humanOnly);
+  const limit = parseLimit(ctx.query.limit);
+  const sessions2 = await listConversationSummaries({ source, humanOnly, limit });
+  ctx.body = { sessions: sessions2 };
+}
+async function getConversationMessages(ctx) {
+  const source = ctx.query.source || void 0;
+  const humanOnly = parseHumanOnly(ctx.query.humanOnly);
+  const detail = await getConversationDetail(ctx.params.id, { source, humanOnly });
+  if (!detail) {
+    ctx.status = 404;
+    ctx.body = { error: "Conversation not found" };
+    return;
+  }
+  ctx.body = detail;
+}
 async function list(ctx) {
   const source = ctx.query.source || void 0;
   const limit = ctx.query.limit ? parseInt(ctx.query.limit, 10) : void 0;
@@ -40836,6 +41176,8 @@ async function rename(ctx) {
 
 // packages/server/src/routes/hermes/sessions.ts
 var sessionRoutes = new router_default();
+sessionRoutes.get("/api/hermes/sessions/conversations", listConversations);
+sessionRoutes.get("/api/hermes/sessions/conversations/:id/messages", getConversationMessages);
 sessionRoutes.get("/api/hermes/sessions", list);
 sessionRoutes.get("/api/hermes/sessions/:id", get);
 sessionRoutes.delete("/api/hermes/sessions/:id", remove);
@@ -41073,6 +41415,7 @@ init_hermes_profile();
 init_logger();
 var PROVIDER_ENV_MAP = {
   openrouter: { api_key_env: "OPENROUTER_API_KEY", base_url_env: "" },
+  "glm-coding-plan": { api_key_env: "", base_url_env: "" },
   zai: { api_key_env: "GLM_API_KEY", base_url_env: "" },
   "kimi-coding-cn": { api_key_env: "KIMI_CN_API_KEY", base_url_env: "" },
   moonshot: { api_key_env: "MOONSHOT_API_KEY", base_url_env: "" },
@@ -41459,8 +41802,8 @@ var PROVIDER_PRESETS = [
     models: ["glm-5.1", "glm-5", "glm-5v-turbo", "glm-5-turbo", "glm-4.7", "glm-4.5", "glm-4.5-flash"]
   },
   {
-    label: "GLMCodingPlan",
-    value: "glm",
+    label: "GLM-Coding-Plan",
+    value: "glm-coding-plan",
     builtin: true,
     base_url: "https://api.z.ai/api/anthropic",
     models: ["glm-5.1", "glm-5", "glm-5-turbo", "glm-4.7", "glm-4.5", "glm-4.5-flash"]
@@ -41732,7 +42075,9 @@ async function getAvailable(ctx) {
         if (!cp.base_url) return null;
         const providerKey = `custom:${cp.name.trim().toLowerCase().replace(/ /g, "-")}`;
         const baseUrl = cp.base_url.replace(/\/+$/, "");
-        let models = [cp.model];
+        const bareKey = cp.name.trim().toLowerCase().replace(/ /g, "-");
+        const builtinPreset = PROVIDER_PRESETS.find((p) => p.value === bareKey);
+        let models = builtinPreset?.models?.length ? [...builtinPreset.models] : [cp.model];
         if (cp.api_key) {
           try {
             const fetched = await fetchProviderModels(baseUrl, cp.api_key);
@@ -41740,7 +42085,9 @@ async function getAvailable(ctx) {
           } catch {
           }
         }
-        return { providerKey, label: cp.name, base_url: baseUrl, models, api_key: cp.api_key || "" };
+        const label = builtinPreset?.label || cp.name;
+        const presetBaseUrl = builtinPreset?.base_url || "";
+        return { providerKey, label, base_url: presetBaseUrl || baseUrl, models, api_key: cp.api_key || "" };
       })
     );
     for (const result of customFetches) {
@@ -41811,6 +42158,7 @@ init_hermes_profile();
 init_logger();
 async function create2(ctx) {
   const { name, base_url, api_key, model, providerKey } = ctx.request.body;
+  console.log(name, base_url, api_key, model, providerKey);
   if (!name || !base_url || !model) {
     ctx.status = 400;
     ctx.body = { error: "Missing name, base_url, or model" };
@@ -41824,36 +42172,55 @@ async function create2(ctx) {
   try {
     const poolKey = providerKey || `custom:${name.trim().toLowerCase().replace(/ /g, "-")}`;
     const isBuiltin = poolKey in PROVIDER_ENV_MAP;
+    const config2 = await readConfigYaml();
+    if (typeof config2.model !== "object" || config2.model === null) {
+      config2.model = {};
+    }
     if (!isBuiltin) {
-      const config3 = await readConfigYaml();
-      if (!Array.isArray(config3.custom_providers)) {
-        config3.custom_providers = [];
+      if (!Array.isArray(config2.custom_providers)) {
+        config2.custom_providers = [];
       }
-      const existing = config3.custom_providers.find(
-        (e) => `custom:${e.name.trim().toLowerCase().replace(/ /g, "-")}` === poolKey
+      const existing = config2.custom_providers.find(
+        (e) => `custom:${e.name}` === poolKey
       );
       if (existing) {
         existing.base_url = base_url;
         existing.api_key = api_key;
         existing.model = model;
       } else {
-        config3.custom_providers.push({ name, base_url, api_key, model });
+        config2.custom_providers.push({ name: name.trim().toLowerCase().replace(/ /g, "-"), base_url, api_key, model });
       }
-      await writeConfigYaml(config3);
-    }
-    const envMapping = isBuiltin ? PROVIDER_ENV_MAP[poolKey] || PROVIDER_ENV_MAP[providerKey || ""] : null;
-    if (envMapping) {
-      await saveEnvValue(envMapping.api_key_env, api_key);
-      if (envMapping.base_url_env) {
-        await saveEnvValue(envMapping.base_url_env, base_url);
+      config2.model.default = model;
+      config2.model.provider = poolKey;
+    } else {
+      console.log(PROVIDER_ENV_MAP[poolKey]);
+      if (PROVIDER_ENV_MAP[poolKey].api_key_env) {
+        await saveEnvValue(PROVIDER_ENV_MAP[poolKey].api_key_env, api_key);
+        if (PROVIDER_ENV_MAP[poolKey].base_url_env) {
+          await saveEnvValue(PROVIDER_ENV_MAP[poolKey].base_url_env, base_url);
+        }
+        config2.model.default = model;
+        config2.model.provider = poolKey;
+      } else {
+        if (!Array.isArray(config2.custom_providers)) {
+          config2.custom_providers = [];
+        }
+        const existing = config2.custom_providers.find(
+          (e) => `custom:${e.name}` === `custom:${poolKey}`
+        );
+        if (existing) {
+          existing.base_url = base_url;
+          existing.api_key = api_key;
+          existing.model = model;
+        } else {
+          config2.custom_providers.push({ name: poolKey, base_url, api_key, model });
+        }
+        config2.model.default = model;
+        config2.model.provider = `custom:${poolKey}`;
       }
     }
-    const config2 = await readConfigYaml();
-    if (typeof config2.model !== "object" || config2.model === null) {
-      config2.model = {};
-    }
-    config2.model.default = model;
-    config2.model.provider = poolKey;
+    delete config2.model.base_url;
+    delete config2.model.api_key;
     await writeConfigYaml(config2);
     try {
       await restartGateway();
@@ -41955,17 +42322,27 @@ async function remove3(ctx) {
     if (currentProvider === poolKey) {
       const freshConfig = await readConfigYaml();
       const remaining = Array.isArray(freshConfig.custom_providers) ? freshConfig.custom_providers : [];
-      const fallbackCp = remaining[0];
-      if (fallbackCp) {
+      if (remaining.length > 0) {
+        const fallbackCp = remaining[0];
         const fallbackKey = `custom:${fallbackCp.name.trim().toLowerCase().replace(/ /g, "-")}`;
         if (typeof freshConfig.model !== "object" || freshConfig.model === null) {
           freshConfig.model = {};
         }
         freshConfig.model.default = fallbackCp.model;
         freshConfig.model.provider = fallbackKey;
+        delete freshConfig.model.base_url;
+        delete freshConfig.model.api_key;
+        await writeConfigYaml(freshConfig);
+      } else {
+        freshConfig.model = {};
         await writeConfigYaml(freshConfig);
       }
     }
+    try {
+      await restartGateway();
+    } catch (e) {
+      logger.error(e, "Gateway restart failed");
+    }
     ctx.body = { success: true };
   } catch (err) {
     ctx.status = 500;
@@ -46668,14 +47045,17 @@ async function proxy(ctx) {
   const profile = resolveProfile(ctx);
   const upstream = resolveUpstream(ctx);
   const upstreamPath = ctx.path.replace(/^\/api\/hermes\/v1/, "/v1").replace(/^\/api\/hermes/, "/api");
-  const url2 = `${upstream}${upstreamPath}${ctx.search || ""}`;
+  const params = new URLSearchParams(ctx.search || "");
+  params.delete("token");
+  const search = params.toString();
+  const url2 = `${upstream}${upstreamPath}${search ? `?${search}` : ""}`;
   const headers = {};
   for (const [key, value] of Object.entries(ctx.headers)) {
     if (value == null) continue;
     const lower = key.toLowerCase();
     if (lower === "host") {
       headers["host"] = new URL(upstream).host;
-    } else if (lower === "origin" || lower === "referer" || lower === "connection") {
+    } else if (lower === "origin" || lower === "referer" || lower === "connection" || lower === "authorization") {
       continue;
     } else {
       const v = Array.isArray(value) ? value[0] : value;
@@ -46783,7 +47163,7 @@ var import_path13 = require("path");
 var import_promises13 = require("fs/promises");
 var import_fs12 = require("fs");
 init_logger();
-var APP_VERSION = true ? "0.4.1" : (() => {
+var APP_VERSION = true ? "0.4.2" : (() => {
   try {
     return JSON.parse(readFileSync7((0, import_path13.resolve)(__dirname, "../../package.json"), "utf-8")).version;
   } catch {