@newbase-clawchat/openclaw-clawchat 2026.4.24 → 2026.4.30

package/src/config.ts

@@ -8,10 +8,9 @@ export const CHANNEL_ID = "openclaw-clawchat" as const;
  * login` works out of the box without requiring a prior `openclaw channel
  * setup` call. Operators can still override either one via config.
  *
- * TODO: replace these placeholders with the production URLs.
  */
-export const DEFAULT_BASE_URL = "https://api.clawling.chat" as const;
-export const DEFAULT_WEBSOCKET_URL = "wss://api.clawling.chat/ws" as const;
+export const DEFAULT_BASE_URL = "http://company.newbaselab.com:10086" as const;
+export const DEFAULT_WEBSOCKET_URL = "ws://company.newbaselab.com:10086/ws" as const;
 
 export type ReplyMode = "static" | "stream";
 
@@ -92,6 +91,8 @@ export type OpenclawClawlingConfig = {
   groupMode?: GroupMode;
   forwardThinking?: boolean;
   forwardToolCalls?: boolean;
+  /** Emit approval/action rich fragments instead of plain fallback text. */
+  richInteractions?: boolean;
   stream?: OpenclawClawlingStreamConfig;
   reconnect?: OpenclawClawlingReconnectConfig;
   heartbeat?: OpenclawClawlingHeartbeatConfig;
@@ -112,6 +113,7 @@ export const openclawClawlingConfigSchema = {
     groupMode: { type: "string", enum: ["mention", "all"] },
     forwardThinking: { type: "boolean" },
     forwardToolCalls: { type: "boolean" },
+    richInteractions: { type: "boolean" },
     stream: {
       type: "object",
       additionalProperties: false,
@@ -150,6 +152,57 @@ export const openclawClawlingConfigSchema = {
   },
 } as const;
 
+function isOpenclawClawchatToolAllowEntry(entry: unknown): boolean {
+  return entry === CHANNEL_ID || entry === "group:plugins";
+}
+
+function hasOpenclawClawchatToolAllow(cfg: OpenClawConfig): boolean {
+  const currentTools = ((cfg as { tools?: Record<string, unknown> }).tools ?? {}) as Record<
+    string,
+    unknown
+  >;
+  const currentAlsoAllow = Array.isArray(currentTools.alsoAllow) ? currentTools.alsoAllow : [];
+  const currentAllow = Array.isArray(currentTools.allow) ? currentTools.allow : [];
+  return [...currentAllow, ...currentAlsoAllow].some(isOpenclawClawchatToolAllowEntry);
+}
+
+function mergeToolPolicyEntryAllow(
+  cfg: OpenClawConfig,
+  entry: string,
+  isAlreadyCovered: (value: unknown) => boolean,
+): OpenClawConfig {
+  const currentTools = ((cfg as { tools?: Record<string, unknown> }).tools ?? {}) as Record<
+    string,
+    unknown
+  >;
+  const currentAlsoAllow = Array.isArray(currentTools.alsoAllow)
+    ? currentTools.alsoAllow.slice()
+    : [];
+  const currentAllow = Array.isArray(currentTools.allow) ? currentTools.allow.slice() : [];
+  const alreadyAllowed = [...currentAllow, ...currentAlsoAllow].some(isAlreadyCovered);
+  if (currentAllow.length > 0) {
+    return {
+      ...cfg,
+      tools: {
+        ...currentTools,
+        allow: alreadyAllowed ? currentAllow : [...currentAllow, entry],
+      },
+    } as OpenClawConfig;
+  }
+  const alreadyAlsoAllowed = currentAlsoAllow.some(isAlreadyCovered);
+  return {
+    ...cfg,
+    tools: {
+      ...currentTools,
+      alsoAllow: alreadyAlsoAllowed ? currentAlsoAllow : [...currentAlsoAllow, entry],
+    },
+  } as OpenClawConfig;
+}
+
+export function mergeOpenclawClawchatToolAllow(cfg: OpenClawConfig): OpenClawConfig {
+  return mergeToolPolicyEntryAllow(cfg, CHANNEL_ID, isOpenclawClawchatToolAllowEntry);
+}
+
 export type ResolvedOpenclawClawlingAccount = {
   accountId: string;
   name: string;
@@ -163,6 +216,7 @@ export type ResolvedOpenclawClawlingAccount = {
   groupMode: GroupMode;
   forwardThinking: boolean;
   forwardToolCalls: boolean;
+  richInteractions: boolean;
   allowFrom: string[];
   stream: Required<OpenclawClawlingStreamConfig>;
   reconnect: Required<OpenclawClawlingReconnectConfig>;
@@ -249,6 +303,8 @@ export function resolveOpenclawClawlingAccount(
     typeof channel.forwardThinking === "boolean" ? channel.forwardThinking : true;
   const forwardToolCalls =
     typeof channel.forwardToolCalls === "boolean" ? channel.forwardToolCalls : false;
+  const richInteractions =
+    typeof channel.richInteractions === "boolean" ? channel.richInteractions : false;
 
   return {
     accountId: DEFAULT_ACCOUNT_ID,
@@ -263,6 +319,7 @@ export function resolveOpenclawClawlingAccount(
     groupMode,
     forwardThinking,
     forwardToolCalls,
+    richInteractions,
     allowFrom: [],
     stream: readStream(channel.stream),
     reconnect: readReconnect(channel.reconnect),
@@ -274,4 +331,3 @@ export function resolveOpenclawClawlingAccount(
 export function listOpenclawClawlingAccountIds(): string[] {
   return [DEFAULT_ACCOUNT_ID];
 }
-

package/src/inbound.test.ts

@@ -41,6 +41,7 @@ function buildSendEnvelope(
     mentions: string[];
     reply: unknown;
     messageId: string;
+    chatId: string;
   }> = {},
 ): Envelope<DownlinkMessageSendPayload> {
   return {
@@ -48,6 +49,7 @@ function buildSendEnvelope(
     event: overrides.event ?? "message.send",
     trace_id: "trace-1",
     emitted_at: 1776162600000,
+    chat_id: overrides.chatId,
     to: { id: "agent-1", type: overrides.senderType ?? "direct" },
     sender: {
       sender_id: "user-1",
@@ -93,7 +95,7 @@ describe("openclaw-clawchat inbound", () => {
       envelope: buildSendEnvelope({ text: "hello there" }),
       cfg: {},
       runtime: {} as never,
-      account: baseAccount(),
+      account: baseAccount({ groupMode: "mention" }),
       ingest,
     });
     expect(ingest).toHaveBeenCalledTimes(1);
@@ -110,7 +112,7 @@ describe("openclaw-clawchat inbound", () => {
       envelope: buildSendEnvelope({ senderType: "direct" }),
       cfg: {},
       runtime: {} as never,
-      account: baseAccount(),
+      account: baseAccount({ groupMode: "mention" }),
       ingest,
     });
     const { wasMentioned } = ingest.mock.calls[0]![0];
@@ -145,7 +147,7 @@ describe("openclaw-clawchat inbound", () => {
       envelope: buildSendEnvelope({ senderType: "group" }),
       cfg: {},
       runtime: {} as never,
-      account: baseAccount(),
+      account: baseAccount({ groupMode: "mention" }),
       ingest,
     });
     expect(ingest).not.toHaveBeenCalled();
@@ -174,7 +176,7 @@ describe("openclaw-clawchat inbound", () => {
       },
     };
     await dispatchOpenclawClawlingInbound({
-      envelope: buildSendEnvelope({ event: "message.reply", reply: replyRef }),
+      envelope: buildSendEnvelope({ event: "message.reply", reply: replyRef, chatId: "chat-1" }),
       cfg: {},
       runtime: {} as never,
       account: baseAccount(),
@@ -183,8 +185,9 @@ describe("openclaw-clawchat inbound", () => {
     const { replyCtx } = ingest.mock.calls[0]![0];
     expect(replyCtx).toEqual({
       replyToMessageId: "m-orig",
+      replyPreviewChatId: "chat-1",
       replyPreviewSenderId: "user-2",
-      replyPreviewDisplayName: "User Two",
+      replyPreviewNickName: "User Two",
       replyPreviewText: "original text",
     });
   });
@@ -262,7 +265,7 @@ describe("openclaw-clawchat inbound", () => {
     expect(ingest).toHaveBeenCalledTimes(1);
     const call = ingest.mock.calls[0]![0];
     expect(call.senderId).toBe("user-1");
-    expect(call.senderDisplayName).toBe("User One");
+    expect(call.senderNickName).toBe("User One");
     expect(call.peer).toEqual({ kind: "direct", id: "user-1" });
   });
 

package/src/inbound.ts

@@ -29,6 +29,7 @@ export interface IngestTurnParams {
   mediaItems: MediaItem[];
   replyCtx?: {
     replyToMessageId: string;
+    replyPreviewChatId: string;
     replyPreviewSenderId: string;
     replyPreviewNickName: string;
     replyPreviewText: string;
@@ -52,6 +53,29 @@ const DEDUP_MAX = 256;
 const dedupSeen: string[] = [];
 const dedupSet = new Set<string>();
 
+type SenderLike = {
+  id?: unknown;
+  nick_name?: unknown;
+  sender_id?: unknown;
+  display_name?: unknown;
+  type?: unknown;
+};
+
+function normalizeSender(sender: unknown): { id: string; nickName: string; type?: ChatType } | null {
+  if (!sender || typeof sender !== "object") return null;
+  const s = sender as SenderLike;
+  const id = typeof s.id === "string" ? s.id : typeof s.sender_id === "string" ? s.sender_id : "";
+  if (!id) return null;
+  const type = s.type === "group" || s.type === "direct" ? s.type : undefined;
+  const nickName =
+    typeof s.nick_name === "string"
+      ? s.nick_name
+      : typeof s.display_name === "string"
+        ? s.display_name
+        : id;
+  return { id, nickName, ...(type ? { type } : {}) };
+}
+
 export function _resetDedupForTest(): void {
   dedupSeen.length = 0;
   dedupSet.clear();
@@ -101,20 +125,22 @@ export async function dispatchOpenclawClawlingInbound(
       reply: {
         reply_to_msg_id: string;
         reply_preview: {
-          id: string;
-          nick_name: string;
+          id?: string;
+          nick_name?: string;
+          sender_id?: string;
+          display_name?: string;
           fragments: Array<Record<string, unknown>>;
         };
       } | null;
     };
     /** Legacy fallback: older fixtures carried sender inside payload.message. */
-    sender?: { id: string; nick_name: string };
+    sender?: SenderLike;
   };
 
   // v2 envelopes carry sender on the envelope (RoutingSender); the legacy
   // message.sender shape is accepted as a fallback for older fixtures.
-  const sender = envelope.sender ?? message.sender;
-  if (!sender || typeof sender.id !== "string" || !sender.id) {
+  const sender = normalizeSender(envelope.sender ?? message.sender);
+  if (!sender) {
     log?.info?.(
       `[${account.accountId}] openclaw-clawchat skip: missing sender trace=${envelope.trace_id}`,
     );
@@ -122,7 +148,10 @@ export async function dispatchOpenclawClawlingInbound(
   }
   // `chat_type` is on the envelope in the new protocol. Default to "direct"
   // if the server didn't include it (defensive; shouldn't happen in practice).
-  const chatType: ChatType = envelope.chat_type ?? "direct";
+  const legacyTo = (envelope as Envelope<DownlinkMessageSendPayload> & {
+    to?: { type?: ChatType };
+  }).to;
+  const chatType: ChatType = envelope.chat_type ?? sender.type ?? legacyTo?.type ?? "direct";
   const isGroup = chatType === "group";
   if (payload.message_mode !== "normal") {
     log?.info?.(
@@ -163,15 +192,6 @@ export async function dispatchOpenclawClawlingInbound(
     return;
   }
 
-  const replyCtx = message.context.reply
-    ? {
-        replyToMessageId: message.context.reply.reply_to_msg_id,
-        replyPreviewSenderId: message.context.reply.reply_preview.id,
-        replyPreviewNickName: message.context.reply.reply_preview.nick_name,
-        replyPreviewText: fragmentsToText(message.context.reply.reply_preview.fragments as never),
-      }
-    : undefined;
-
   log?.info?.(
     `[${account.accountId}] openclaw-clawchat inbound event=${envelope.event === EVENT.MESSAGE_REPLY ? "reply" : "send"} msg=${payload.message_id} from=${sender.id} text_len=${rawBody.length} mentioned=${wasMentioned}`,
   );
@@ -181,13 +201,28 @@ export async function dispatchOpenclawClawlingInbound(
   const chatId =
     (envelope as Envelope<DownlinkMessageSendPayload> & { chat_id?: string }).chat_id ??
     sender.id;
+  const replyCtx = message.context.reply
+    ? {
+        replyToMessageId: message.context.reply.reply_to_msg_id,
+        replyPreviewChatId: chatId,
+        replyPreviewSenderId:
+          message.context.reply.reply_preview.id ??
+          message.context.reply.reply_preview.sender_id ??
+          "",
+        replyPreviewNickName:
+          message.context.reply.reply_preview.nick_name ??
+          message.context.reply.reply_preview.display_name ??
+          "",
+        replyPreviewText: fragmentsToText(message.context.reply.reply_preview.fragments as never),
+      }
+    : undefined;
 
   await params.ingest({
     channel: "openclaw-clawchat",
     accountId: account.accountId,
     peer: { kind: isGroup ? "group" : "direct", id: chatId },
     senderId: sender.id,
-    senderNickName: sender.nick_name,
+    senderNickName: sender.nickName,
     rawBody,
     messageId: payload.message_id,
     traceId: envelope.trace_id,

package/src/login.runtime.test.ts

@@ -95,7 +95,7 @@ describe("runOpenclawClawlingLogin", () => {
     });
 
     expect(agentsConnect).toHaveBeenCalledWith({
-      inviteCode: "INV-ABC",
+      code: "INV-ABC",
       platform: "openclaw",
       type: "clawbot",
     });
@@ -112,6 +112,145 @@ describe("runOpenclawClawlingLogin", () => {
     expect(log).toHaveBeenCalledWith(expect.stringContaining("login succeeded"));
   });
 
+  it("uses the runtime config mutator with auto reload intent for config writes", async () => {
+    const cfg = buildCfg({
+      baseUrl: "https://api.example.com",
+      websocketUrl: "wss://ws.example.com/v2/client",
+    });
+    const agentsConnect = vi.fn().mockResolvedValue({
+      agent: { user_id: "agent-123", nickname: "Bot" },
+      access_token: "access-tok",
+      refresh_token: "refresh-tok",
+    });
+    let mutatedCfg: OpenClawConfig | undefined;
+    const mutateConfigFile = vi.fn(async (params) => {
+      expect(params.afterWrite).toEqual({ mode: "auto" });
+      const draft = structuredClone(cfg) as OpenClawConfig;
+      await params.mutate(draft, { snapshot: {} as never, previousHash: "before" });
+      mutatedCfg = draft;
+      return { nextConfig: draft } as never;
+    });
+
+    await runOpenclawClawlingLogin({
+      cfg,
+      runtime: { log: vi.fn() },
+      readInviteCode: async () => "INV-ABC",
+      apiClientFactory: () => makeApiClient({ agentsConnect }),
+      mutateConfigFile,
+    });
+
+    expect(mutateConfigFile).toHaveBeenCalledTimes(1);
+    const section = (mutatedCfg!.channels as Record<string, Record<string, unknown>>)[
+      CHANNEL_ID
+    ]!;
+    expect(section.token).toBe("access-tok");
+    expect(section.refreshToken).toBe("refresh-tok");
+    expect(section.userId).toBe("agent-123");
+  });
+
+  it("preserves other configured channels when persisting ClawChat credentials", async () => {
+    const cfg = {
+      channels: {
+        telegram: {
+          enabled: true,
+          token: "telegram-token",
+        },
+        [CHANNEL_ID]: {
+          baseUrl: "https://api.example.com",
+          websocketUrl: "wss://ws.example.com/v2/client",
+        },
+      },
+    } as unknown as OpenClawConfig;
+    const agentsConnect = vi.fn().mockResolvedValue({
+      agent: { user_id: "agent-123" },
+      access_token: "access-tok",
+      refresh_token: "refresh-tok",
+    });
+    const persistConfig = vi.fn();
+
+    await runOpenclawClawlingLogin({
+      cfg,
+      runtime: { log: vi.fn() },
+      readInviteCode: async () => "INV-ABC",
+      apiClientFactory: () => makeApiClient({ agentsConnect }),
+      persistConfig,
+    });
+
+    const savedCfg = persistConfig.mock.calls[0]![0] as OpenClawConfig;
+    expect(savedCfg.channels?.telegram).toEqual({
+      enabled: true,
+      token: "telegram-token",
+    });
+    expect(savedCfg.channels?.[CHANNEL_ID]).toMatchObject({
+      baseUrl: "https://api.example.com",
+      websocketUrl: "wss://ws.example.com/v2/client",
+      token: "access-tok",
+      userId: "agent-123",
+      refreshToken: "refresh-tok",
+    });
+  });
+
+  it("enables the channel when login fills a pre-activation disabled skeleton", async () => {
+    const cfg = buildCfg({
+      enabled: false,
+      baseUrl: "https://api.example.com",
+    });
+    const agentsConnect = vi.fn().mockResolvedValue({
+      agent: { user_id: "agent-123" },
+      access_token: "access-tok",
+      refresh_token: "refresh-tok",
+    });
+    const persistConfig = vi.fn();
+
+    await runOpenclawClawlingLogin({
+      cfg,
+      runtime: { log: vi.fn() },
+      readInviteCode: async () => "INV-ABC",
+      apiClientFactory: () => makeApiClient({ agentsConnect }),
+      persistConfig,
+    });
+
+    const savedCfg = persistConfig.mock.calls[0]![0] as OpenClawConfig;
+    const section = (savedCfg.channels as Record<string, Record<string, unknown>>)[CHANNEL_ID]!;
+    expect(section.enabled).toBe(true);
+    expect(section.token).toBe("access-tok");
+    expect(section.userId).toBe("agent-123");
+  });
+
+  it("allows openclaw-clawchat plugin tools after successful login without replacing policy", async () => {
+    const cfg = {
+      ...buildCfg({ baseUrl: "https://api.example.com" }),
+      tools: {
+        profile: "coding",
+        allow: [],
+        deny: ["exec"],
+        alsoAllow: ["browser"],
+      },
+    } as unknown as OpenClawConfig;
+    const agentsConnect = vi.fn().mockResolvedValue({
+      agent: { user_id: "agent-123" },
+      access_token: "access-tok",
+      refresh_token: "refresh-tok",
+    });
+    const persistConfig = vi.fn();
+
+    await runOpenclawClawlingLogin({
+      cfg,
+      runtime: { log: vi.fn() },
+      readInviteCode: async () => "INV-ABC",
+      apiClientFactory: () => makeApiClient({ agentsConnect }),
+      persistConfig,
+    });
+
+    const savedCfg = persistConfig.mock.calls[0]![0] as OpenClawConfig;
+    expect(savedCfg.tools).toMatchObject({
+      profile: "coding",
+      allow: [],
+      deny: ["exec"],
+      alsoAllow: ["browser", "openclaw-clawchat"],
+    });
+  });
+
   it("surfaces agents/connect API errors with the kind and message", async () => {
     const cfg = buildCfg({ baseUrl: "https://api.example.com" });
     const agentsConnect = vi.fn().mockRejectedValue(
@@ -219,7 +358,7 @@ describe("runOpenclawClawlingLogin", () => {
       persistConfig: vi.fn(),
     });
     expect(agentsConnect).toHaveBeenCalledWith({
-      inviteCode: "INV-TRIM",
+      code: "INV-TRIM",
       platform: "openclaw",
       type: "clawbot",
     });
@@ -243,7 +382,7 @@ describe("runOpenclawClawlingLogin (non-interactive via readInviteCode)", () =>
       persistConfig,
     });
     expect(agentsConnect).toHaveBeenCalledWith({
-      inviteCode: "INV-PROGRAMMATIC",
+      code: "INV-PROGRAMMATIC",
       platform: "openclaw",
       type: "clawbot",
     });

package/src/login.runtime.ts

@@ -1,9 +1,12 @@
 import { createInterface, type Interface as ReadlineInterface } from "node:readline/promises";
-import { writeConfigFile } from "openclaw/plugin-sdk/config-runtime";
 import type { OpenClawConfig } from "openclaw/plugin-sdk/core";
 import { createOpenclawClawlingApiClient } from "./api-client.ts";
-import { ClawlingApiError } from "./api-types.ts";
-import { CHANNEL_ID, resolveOpenclawClawlingAccount } from "./config.ts";
+import { ClawlingApiError, type AgentConnectResult } from "./api-types.ts";
+import {
+  CHANNEL_ID,
+  mergeOpenclawClawchatToolAllow,
+  resolveOpenclawClawlingAccount,
+} from "./config.ts";
 
 /**
  * Platform tag sent to `/v1/agents/connect`. Identifies the host of this
@@ -16,6 +19,14 @@ export const AGENTS_CONNECT_PLATFORM = "openclaw" as const;
  */
 export const AGENTS_CONNECT_TYPE = "clawbot" as const;
 
+export type OpenclawClawchatMutateConfigFile = <T = void>(params: {
+  afterWrite: { mode: "auto" } | { mode: "none" | "restart"; reason: string };
+  mutate: (
+    draft: OpenClawConfig,
+    context: { snapshot: unknown; previousHash: string | null },
+  ) => Promise<T | void> | T | void;
+}) => Promise<unknown>;
+
 export interface LoginParams {
   cfg: OpenClawConfig;
   accountId?: string | null;
@@ -27,7 +38,9 @@ export interface LoginParams {
   readInviteCode?: () => Promise<string>;
   /** Override for the HTTP client — used by tests. */
   apiClientFactory?: typeof createOpenclawClawlingApiClient;
-  /** Override for config persistence — used by tests. */
+  /** Official runtime config mutator. Production callers must provide this. */
+  mutateConfigFile?: OpenclawClawchatMutateConfigFile;
+  /** Test-only config persistence override. */
   persistConfig?: (cfg: OpenClawConfig) => Promise<void> | void;
 }
 
@@ -56,6 +69,46 @@ async function promptInviteCodeFromStdin(runtime: {
   }
 }
 
+function buildLoginConfig(cfg: OpenClawConfig, result: AgentConnectResult): OpenClawConfig {
+  const channels = (cfg.channels ?? {}) as Record<string, unknown>;
+  const existing = (channels[CHANNEL_ID] ?? {}) as Record<string, unknown>;
+  const nextSection: Record<string, unknown> = {
+    ...existing,
+    enabled: true,
+    token: result.access_token,
+    userId: result.agent.user_id,
+  };
+  if (result.refresh_token) {
+    nextSection.refreshToken = result.refresh_token;
+  }
+  return mergeOpenclawClawchatToolAllow({
+    ...cfg,
+    channels: { ...channels, [CHANNEL_ID]: nextSection },
+  });
+}
+
+async function persistLoginConfig(
+  params: LoginParams,
+  result: AgentConnectResult,
+): Promise<void> {
+  if (params.mutateConfigFile) {
+    await params.mutateConfigFile({
+      afterWrite: { mode: "auto" },
+      mutate(draft) {
+        Object.assign(draft, buildLoginConfig(draft, result));
+      },
+    });
+    return;
+  }
+
+  if (params.persistConfig) {
+    await params.persistConfig(buildLoginConfig(params.cfg, result));
+    return;
+  }
+
+  throw new Error("openclaw-clawchat: mutateConfigFile is required to persist login credentials");
+}
+
 /**
  * Run the `openclaw channels login --channel openclaw-clawchat` flow:
  *   1. Read the existing channel section; require `baseUrl` to be set so we
@@ -63,7 +116,7 @@ async function promptInviteCodeFromStdin(runtime: {
  *   2. Prompt the user for an invite code on stdin.
  *   3. POST it to `${baseUrl}/v1/agents/connect`.
  *   4. Write the returned `websocket_url` / `token` / `user_id` back into
- *      the config so subsequent `openclaw gateway run` picks them up.
+ *      the config so subsequent Gateway runs pick them up.
  *
  * Errors surface with clear messages (missing baseUrl, empty invite,
  * server-side rejection) so the caller can relay them to the operator.
@@ -111,33 +164,13 @@ export async function runOpenclawClawlingLogin(params: LoginParams): Promise<voi
     );
   }
 
-  // Merge credentials into cfg.channels.openclaw-clawchat and persist
-  // immediately so a subsequent `openclaw gateway run` picks them up
-  // without any manual edit. `baseUrl` / `websocketUrl` stay untouched —
-  // the built-in defaults (or operator overrides) remain authoritative
-  // because `/v1/agents/connect` doesn't return them.
-  const channels = (cfg.channels ?? {}) as Record<string, unknown>;
-  const existing = (channels[CHANNEL_ID] ?? {}) as Record<string, unknown>;
-  const nextSection: Record<string, unknown> = {
-    ...existing,
-    token: result.access_token,
-    userId: result.agent.user_id,
-  };
-  if (result.refresh_token) {
-    nextSection.refreshToken = result.refresh_token;
-  }
-  const nextCfg: OpenClawConfig = {
-    ...cfg,
-    channels: { ...channels, [CHANNEL_ID]: nextSection },
-  };
-
   const tokenPreview = redactToken(result.access_token);
   runtime.log(
     `Updating config: channels.${CHANNEL_ID}.token=${tokenPreview} userId=${result.agent.user_id}${
       result.refresh_token ? " refreshToken=***" : ""
     } …`,
   );
-  await (params.persistConfig ?? writeConfigFile)(nextCfg);
+  await persistLoginConfig(params, result);
   runtime.log(`Config file updated.`);
 
   runtime.log(