@kodelyth/googlechat 2026.5.39 → 2026.5.42

package/src/channel.ts

@@ -0,0 +1,277 @@
+import { describeAccountSnapshot } from "klaw/plugin-sdk/account-helpers";
+import { formatNormalizedAllowFromEntries } from "klaw/plugin-sdk/allow-from";
+import {
+  adaptScopedAccountAccessor,
+  createScopedChannelConfigAdapter,
+} from "klaw/plugin-sdk/channel-config-helpers";
+import type { ChannelMessageActionName } from "klaw/plugin-sdk/channel-contract";
+import { createChatChannelPlugin } from "klaw/plugin-sdk/channel-core";
+import { buildPassiveProbedChannelStatusSummary } from "klaw/plugin-sdk/extension-shared";
+import { createLazyRuntimeNamedExport } from "klaw/plugin-sdk/lazy-runtime";
+import {
+  createComputedAccountStatusAdapter,
+  createDefaultChannelRuntimeState,
+} from "klaw/plugin-sdk/status-helpers";
+import { extractToolSend } from "klaw/plugin-sdk/tool-send";
+import { googleChatApprovalAuth } from "./approval-auth.js";
+import {
+  formatAllowFromEntry,
+  googlechatDirectoryAdapter,
+  googlechatGroupsAdapter,
+  googlechatMessageAdapter,
+  googlechatOutboundAdapter,
+  googlechatPairingTextAdapter,
+  googlechatSecurityAdapter,
+  googlechatThreadingAdapter,
+} from "./channel.adapters.js";
+import {
+  buildChannelConfigSchema,
+  DEFAULT_ACCOUNT_ID,
+  GoogleChatConfigSchema,
+  isGoogleChatSpaceTarget,
+  isGoogleChatUserTarget,
+  listGoogleChatAccountIds,
+  normalizeGoogleChatTarget,
+  type GoogleChatConfigAccessorAccount,
+  resolveGoogleChatConfigAccessorAccount,
+  resolveDefaultGoogleChatAccountId,
+  resolveGoogleChatAccount,
+  type ChannelMessageActionAdapter,
+  type ChannelStatusIssue,
+  type ResolvedGoogleChatAccount,
+} from "./channel.deps.runtime.js";
+import {
+  legacyConfigRules as GOOGLECHAT_LEGACY_CONFIG_RULES,
+  normalizeCompatibilityConfig as normalizeGoogleChatCompatibilityConfig,
+} from "./doctor-contract.js";
+import { collectGoogleChatMutableAllowlistWarnings } from "./doctor.js";
+import { startGoogleChatGatewayAccount } from "./gateway.js";
+import { collectRuntimeConfigAssignments, secretTargetRegistryEntries } from "./secret-contract.js";
+import { googlechatSetupAdapter } from "./setup-core.js";
+import { googlechatSetupWizard } from "./setup-surface.js";
+
+const loadGoogleChatChannelRuntime = createLazyRuntimeNamedExport(
+  () => import("./channel.runtime.js"),
+  "googleChatChannelRuntime",
+);
+
+const meta = {
+  id: "googlechat",
+  label: "Google Chat",
+  selectionLabel: "Google Chat (Chat API)",
+  docsPath: "/channels/googlechat",
+  docsLabel: "googlechat",
+  blurb: "Google Workspace Chat app with HTTP webhook.",
+  aliases: ["gchat", "google-chat"],
+  order: 55,
+  detailLabel: "Google Chat",
+  systemImage: "message.badge",
+  markdownCapable: true,
+};
+
+const googleChatConfigAdapter = createScopedChannelConfigAdapter<
+  ResolvedGoogleChatAccount,
+  GoogleChatConfigAccessorAccount
+>({
+  sectionKey: "googlechat",
+  listAccountIds: listGoogleChatAccountIds,
+  resolveAccount: adaptScopedAccountAccessor(resolveGoogleChatAccount),
+  resolveAccessorAccount: resolveGoogleChatConfigAccessorAccount,
+  defaultAccountId: resolveDefaultGoogleChatAccountId,
+  clearBaseFields: [
+    "serviceAccount",
+    "serviceAccountFile",
+    "audienceType",
+    "audience",
+    "webhookPath",
+    "webhookUrl",
+    "botUser",
+    "name",
+  ],
+  resolveAllowFrom: (account) => account.config.dm?.allowFrom,
+  formatAllowFrom: (allowFrom) =>
+    formatNormalizedAllowFromEntries({
+      allowFrom,
+      normalizeEntry: formatAllowFromEntry,
+    }),
+  resolveDefaultTo: (account) => account.config.defaultTo,
+});
+
+const googlechatActions: ChannelMessageActionAdapter = {
+  describeMessageTool: ({ cfg, accountId }) => {
+    const accounts = accountId
+      ? [resolveGoogleChatAccount({ cfg, accountId })].filter(
+          (account) => account.enabled && account.credentialSource !== "none",
+        )
+      : listGoogleChatAccountIds(cfg)
+          .map((id) => resolveGoogleChatAccount({ cfg, accountId: id }))
+          .filter((account) => account.enabled && account.credentialSource !== "none");
+    if (accounts.length === 0) {
+      return null;
+    }
+    const actions = new Set<ChannelMessageActionName>(["send", "upload-file"]);
+    if (accounts.some((account) => account.config.actions?.reactions !== false)) {
+      actions.add("react");
+      actions.add("reactions");
+    }
+    return { actions: Array.from(actions) };
+  },
+  extractToolSend: ({ args }) => extractToolSend(args, "sendMessage"),
+  handleAction: async (ctx) => {
+    const { googlechatMessageActions } = await import("./actions.js");
+    if (!googlechatMessageActions.handleAction) {
+      throw new Error("Google Chat actions are not available.");
+    }
+    return await googlechatMessageActions.handleAction(ctx);
+  },
+};
+
+export const googlechatPlugin = createChatChannelPlugin({
+  base: {
+    id: "googlechat",
+    meta: { ...meta },
+    setup: googlechatSetupAdapter,
+    setupWizard: googlechatSetupWizard,
+    capabilities: {
+      chatTypes: ["direct", "group", "thread"],
+      reactions: true,
+      threads: true,
+      media: true,
+      nativeCommands: false,
+      blockStreaming: true,
+    },
+    streaming: {
+      blockStreamingCoalesceDefaults: { minChars: 1500, idleMs: 1000 },
+    },
+    reload: { configPrefixes: ["channels.googlechat"] },
+    configSchema: buildChannelConfigSchema(GoogleChatConfigSchema),
+    config: {
+      ...googleChatConfigAdapter,
+      isConfigured: (account) => account.credentialSource !== "none",
+      describeAccount: (account) =>
+        describeAccountSnapshot({
+          account,
+          configured: account.credentialSource !== "none",
+          extra: {
+            credentialSource: account.credentialSource,
+          },
+        }),
+    },
+    approvalCapability: googleChatApprovalAuth,
+    secrets: {
+      secretTargetRegistryEntries,
+      collectRuntimeConfigAssignments,
+    },
+    groups: googlechatGroupsAdapter,
+    messaging: {
+      targetPrefixes: ["googlechat", "google-chat", "gchat"],
+      normalizeTarget: normalizeGoogleChatTarget,
+      targetResolver: {
+        looksLikeId: (raw, normalized) => {
+          const value = normalized ?? raw.trim();
+          return isGoogleChatSpaceTarget(value) || isGoogleChatUserTarget(value);
+        },
+        hint: "<spaces/{space}|users/{user}>",
+      },
+    },
+    directory: googlechatDirectoryAdapter,
+    message: googlechatMessageAdapter,
+    resolver: {
+      resolveTargets: async ({ inputs, kind }) => {
+        const resolved = inputs.map((input) => {
+          const normalized = normalizeGoogleChatTarget(input);
+          if (!normalized) {
+            return { input, resolved: false, note: "empty target" };
+          }
+          if (kind === "user" && isGoogleChatUserTarget(normalized)) {
+            return { input, resolved: true, id: normalized };
+          }
+          if (kind === "group" && isGoogleChatSpaceTarget(normalized)) {
+            return { input, resolved: true, id: normalized };
+          }
+          return {
+            input,
+            resolved: false,
+            note: "use spaces/{space} or users/{user}",
+          };
+        });
+        return resolved;
+      },
+    },
+    actions: googlechatActions,
+    doctor: {
+      dmAllowFromMode: "nestedOnly",
+      groupModel: "route",
+      groupAllowFromFallbackToAllowFrom: false,
+      warnOnEmptyGroupSenderAllowlist: false,
+      legacyConfigRules: GOOGLECHAT_LEGACY_CONFIG_RULES,
+      normalizeCompatibilityConfig: normalizeGoogleChatCompatibilityConfig,
+      collectMutableAllowlistWarnings: collectGoogleChatMutableAllowlistWarnings,
+    },
+    status: createComputedAccountStatusAdapter<ResolvedGoogleChatAccount>({
+      defaultRuntime: createDefaultChannelRuntimeState(DEFAULT_ACCOUNT_ID),
+      collectStatusIssues: (accounts): ChannelStatusIssue[] =>
+        accounts.flatMap((entry) => {
+          const accountId = entry.accountId ?? DEFAULT_ACCOUNT_ID;
+          const enabled = entry.enabled !== false;
+          const configured = entry.configured === true;
+          if (!enabled || !configured) {
+            return [];
+          }
+          const issues: ChannelStatusIssue[] = [];
+          if (!entry.audience) {
+            issues.push({
+              channel: "googlechat",
+              accountId,
+              kind: "config",
+              message: "Google Chat audience is missing (set channels.googlechat.audience).",
+              fix: "Set channels.googlechat.audienceType and channels.googlechat.audience.",
+            });
+          }
+          if (!entry.audienceType) {
+            issues.push({
+              channel: "googlechat",
+              accountId,
+              kind: "config",
+              message: "Google Chat audienceType is missing (app-url or project-number).",
+              fix: "Set channels.googlechat.audienceType and channels.googlechat.audience.",
+            });
+          }
+          return issues;
+        }),
+      buildChannelSummary: ({ snapshot }) =>
+        buildPassiveProbedChannelStatusSummary(snapshot, {
+          credentialSource: snapshot.credentialSource ?? "none",
+          audienceType: snapshot.audienceType ?? null,
+          audience: snapshot.audience ?? null,
+          webhookPath: snapshot.webhookPath ?? null,
+          webhookUrl: snapshot.webhookUrl ?? null,
+        }),
+      probeAccount: async ({ account }) =>
+        (await loadGoogleChatChannelRuntime()).probeGoogleChat(account),
+      resolveAccountSnapshot: ({ account }) => ({
+        accountId: account.accountId,
+        name: account.name,
+        enabled: account.enabled,
+        configured: account.credentialSource !== "none",
+        extra: {
+          credentialSource: account.credentialSource,
+          audienceType: account.config.audienceType,
+          audience: account.config.audience,
+          webhookPath: account.config.webhookPath,
+          webhookUrl: account.config.webhookUrl,
+          dmPolicy: account.config.dm?.policy ?? "pairing",
+        },
+      }),
+    }),
+    gateway: {
+      startAccount: startGoogleChatGatewayAccount,
+    },
+  },
+  pairing: {
+    text: googlechatPairingTextAdapter,
+  },
+  security: googlechatSecurityAdapter,
+  threading: googlechatThreadingAdapter,
+  outbound: googlechatOutboundAdapter,
+});

package/src/config-schema.test.ts

@@ -0,0 +1,31 @@
+import { describe, expect, it } from "vitest";
+import { GoogleChatConfigSchema } from "../runtime-api.js";
+
+describe("googlechat config schema", () => {
+  it("accepts serviceAccount refs", () => {
+    const result = GoogleChatConfigSchema.safeParse({
+      serviceAccountRef: {
+        source: "file",
+        provider: "filemain",
+        id: "/channels/googlechat/serviceAccount",
+      },
+    });
+
+    expect(result.success).toBe(true);
+  });
+
+  it("accepts the documented group config shape", () => {
+    const result = GoogleChatConfigSchema.safeParse({
+      groups: {
+        "spaces/AAAA": {
+          enabled: true,
+          requireMention: true,
+          users: ["users/1234567890"],
+          systemPrompt: "Short answers only.",
+        },
+      },
+    });
+
+    expect(result.success).toBe(true);
+  });
+});

package/src/config-schema.ts

@@ -0,0 +1,3 @@
+import { buildChannelConfigSchema, GoogleChatConfigSchema } from "../config-api.js";
+
+export const GoogleChatChannelConfigSchema = buildChannelConfigSchema(GoogleChatConfigSchema);

package/src/doctor-contract.test.ts

@@ -0,0 +1,75 @@
+import { describe, expect, it } from "vitest";
+import { normalizeCompatibilityConfig } from "./doctor-contract.js";
+
+describe("googlechat doctor contract", () => {
+  it("removes legacy streamMode keys", () => {
+    const result = normalizeCompatibilityConfig({
+      cfg: {
+        channels: {
+          googlechat: {
+            streamMode: "append",
+            accounts: {
+              work: {
+                streamMode: "replace",
+              },
+            },
+          },
+        },
+      } as never,
+    });
+
+    expect(result.changes).toEqual([
+      "Removed channels.googlechat.streamMode (legacy key no longer used).",
+      "Removed channels.googlechat.accounts.work.streamMode (legacy key no longer used).",
+    ]);
+    expect(result.config.channels?.googlechat).toEqual({
+      accounts: {
+        work: {},
+      },
+    });
+  });
+
+  it("moves legacy group allow toggles into enabled", () => {
+    const result = normalizeCompatibilityConfig({
+      cfg: {
+        channels: {
+          googlechat: {
+            groups: {
+              "spaces/aaa": {
+                allow: false,
+              },
+              "spaces/bbb": {
+                allow: true,
+                enabled: false,
+              },
+            },
+            accounts: {
+              work: {
+                groups: {
+                  "spaces/ccc": {
+                    allow: true,
+                  },
+                },
+              },
+            },
+          },
+        },
+      } as never,
+    });
+
+    expect(result.changes).toEqual([
+      "Moved channels.googlechat.groups.spaces/aaa.allow → channels.googlechat.groups.spaces/aaa.enabled.",
+      "Removed channels.googlechat.groups.spaces/bbb.allow (channels.googlechat.groups.spaces/bbb.enabled already set).",
+      "Moved channels.googlechat.accounts.work.groups.spaces/ccc.allow → channels.googlechat.accounts.work.groups.spaces/ccc.enabled.",
+    ]);
+    expect(result.config.channels?.googlechat?.groups?.["spaces/aaa"]).toEqual({
+      enabled: false,
+    });
+    expect(result.config.channels?.googlechat?.groups?.["spaces/bbb"]).toEqual({
+      enabled: false,
+    });
+    expect(result.config.channels?.googlechat?.accounts?.work?.groups?.["spaces/ccc"]).toEqual({
+      enabled: true,
+    });
+  });
+});

package/src/doctor-contract.ts

@@ -0,0 +1,182 @@
+import type {
+  ChannelDoctorConfigMutation,
+  ChannelDoctorLegacyConfigRule,
+} from "klaw/plugin-sdk/channel-contract";
+import type { KlawConfig } from "klaw/plugin-sdk/config-contracts";
+import { asObjectRecord } from "klaw/plugin-sdk/runtime-doctor";
+
+type GoogleChatChannelsConfig = NonNullable<KlawConfig["channels"]>;
+
+function hasLegacyGoogleChatStreamMode(value: unknown): boolean {
+  return asObjectRecord(value)?.streamMode !== undefined;
+}
+
+function hasLegacyGoogleChatGroupAllowAlias(value: unknown): boolean {
+  const groups = asObjectRecord(asObjectRecord(value)?.groups);
+  if (!groups) {
+    return false;
+  }
+  return Object.values(groups).some((group) =>
+    Object.prototype.hasOwnProperty.call(asObjectRecord(group) ?? {}, "allow"),
+  );
+}
+
+function hasLegacyAccountAliases(value: unknown, match: (entry: unknown) => boolean): boolean {
+  const accounts = asObjectRecord(value);
+  if (!accounts) {
+    return false;
+  }
+  return Object.values(accounts).some((account) => match(account));
+}
+
+function normalizeGoogleChatGroups(params: {
+  groups: Record<string, unknown>;
+  pathPrefix: string;
+  changes: string[];
+}): { groups: Record<string, unknown>; changed: boolean } {
+  let changed = false;
+  const nextGroups = { ...params.groups };
+  for (const [groupId, groupValue] of Object.entries(params.groups)) {
+    const group = asObjectRecord(groupValue);
+    if (!group || !Object.prototype.hasOwnProperty.call(group, "allow")) {
+      continue;
+    }
+    const nextGroup = { ...group };
+    if (nextGroup.enabled === undefined) {
+      nextGroup.enabled = group.allow;
+      params.changes.push(
+        `Moved ${params.pathPrefix}.${groupId}.allow → ${params.pathPrefix}.${groupId}.enabled.`,
+      );
+    } else {
+      params.changes.push(
+        `Removed ${params.pathPrefix}.${groupId}.allow (${params.pathPrefix}.${groupId}.enabled already set).`,
+      );
+    }
+    delete nextGroup.allow;
+    nextGroups[groupId] = nextGroup;
+    changed = true;
+  }
+  return { groups: nextGroups, changed };
+}
+
+function normalizeGoogleChatEntry(params: {
+  entry: Record<string, unknown>;
+  pathPrefix: string;
+  changes: string[];
+}): { entry: Record<string, unknown>; changed: boolean } {
+  let updated = params.entry;
+  let changed = false;
+
+  if (updated.streamMode !== undefined) {
+    updated = { ...updated };
+    delete updated.streamMode;
+    params.changes.push(`Removed ${params.pathPrefix}.streamMode (legacy key no longer used).`);
+    changed = true;
+  }
+
+  const groups = asObjectRecord(updated.groups);
+  if (groups) {
+    const normalized = normalizeGoogleChatGroups({
+      groups,
+      pathPrefix: `${params.pathPrefix}.groups`,
+      changes: params.changes,
+    });
+    if (normalized.changed) {
+      updated = { ...updated, groups: normalized.groups };
+      changed = true;
+    }
+  }
+
+  return { entry: updated, changed };
+}
+
+export const legacyConfigRules: ChannelDoctorLegacyConfigRule[] = [
+  {
+    path: ["channels", "googlechat"],
+    message: "channels.googlechat.streamMode is legacy and no longer used; it is removed on load.",
+    match: hasLegacyGoogleChatStreamMode,
+  },
+  {
+    path: ["channels", "googlechat", "accounts"],
+    message:
+      "channels.googlechat.accounts.<id>.streamMode is legacy and no longer used; it is removed on load.",
+    match: (value) => hasLegacyAccountAliases(value, hasLegacyGoogleChatStreamMode),
+  },
+  {
+    path: ["channels", "googlechat"],
+    message:
+      'channels.googlechat.groups.<id>.allow is legacy; use channels.googlechat.groups.<id>.enabled instead. Run "klaw doctor --fix".',
+    match: hasLegacyGoogleChatGroupAllowAlias,
+  },
+  {
+    path: ["channels", "googlechat", "accounts"],
+    message:
+      'channels.googlechat.accounts.<id>.groups.<id>.allow is legacy; use channels.googlechat.accounts.<id>.groups.<id>.enabled instead. Run "klaw doctor --fix".',
+    match: (value) => hasLegacyAccountAliases(value, hasLegacyGoogleChatGroupAllowAlias),
+  },
+];
+
+export function normalizeCompatibilityConfig({
+  cfg,
+}: {
+  cfg: KlawConfig;
+}): ChannelDoctorConfigMutation {
+  const rawEntry = asObjectRecord(
+    (cfg.channels as Record<string, unknown> | undefined)?.googlechat,
+  );
+  if (!rawEntry) {
+    return { config: cfg, changes: [] };
+  }
+
+  const changes: string[] = [];
+  let updated = rawEntry;
+  let changed = false;
+
+  const root = normalizeGoogleChatEntry({
+    entry: updated,
+    pathPrefix: "channels.googlechat",
+    changes,
+  });
+  updated = root.entry;
+  changed = root.changed;
+
+  const accounts = asObjectRecord(updated.accounts);
+  if (accounts) {
+    let accountsChanged = false;
+    const nextAccounts = { ...accounts };
+    for (const [accountId, accountValue] of Object.entries(accounts)) {
+      const account = asObjectRecord(accountValue);
+      if (!account) {
+        continue;
+      }
+      const normalized = normalizeGoogleChatEntry({
+        entry: account,
+        pathPrefix: `channels.googlechat.accounts.${accountId}`,
+        changes,
+      });
+      if (!normalized.changed) {
+        continue;
+      }
+      nextAccounts[accountId] = normalized.entry;
+      accountsChanged = true;
+    }
+    if (accountsChanged) {
+      updated = { ...updated, accounts: nextAccounts };
+      changed = true;
+    }
+  }
+
+  if (!changed) {
+    return { config: cfg, changes: [] };
+  }
+  return {
+    config: {
+      ...cfg,
+      channels: {
+        ...cfg.channels,
+        googlechat: updated as GoogleChatChannelsConfig["googlechat"],
+      },
+    },
+    changes,
+  };
+}

package/src/doctor.ts

@@ -0,0 +1,57 @@
+import { createDangerousNameMatchingMutableAllowlistWarningCollector } from "klaw/plugin-sdk/channel-policy";
+
+function asObjectRecord(value: unknown): Record<string, unknown> | null {
+  return value && typeof value === "object" && !Array.isArray(value)
+    ? (value as Record<string, unknown>)
+    : null;
+}
+
+function isGoogleChatMutableAllowEntry(raw: string): boolean {
+  const text = raw.trim();
+  if (!text || text === "*") {
+    return false;
+  }
+
+  const withoutPrefix = text.replace(/^(googlechat|google-chat|gchat):/i, "").trim();
+  if (!withoutPrefix) {
+    return false;
+  }
+
+  const withoutUsers = withoutPrefix.replace(/^users\//i, "");
+  return withoutUsers.includes("@");
+}
+
+export const collectGoogleChatMutableAllowlistWarnings =
+  createDangerousNameMatchingMutableAllowlistWarningCollector({
+    channel: "googlechat",
+    detector: isGoogleChatMutableAllowEntry,
+    collectLists: (scope) => {
+      const lists = [
+        {
+          pathLabel: `${scope.prefix}.groupAllowFrom`,
+          list: scope.account.groupAllowFrom,
+        },
+      ];
+      const dm = asObjectRecord(scope.account.dm);
+      if (dm) {
+        lists.push({
+          pathLabel: `${scope.prefix}.dm.allowFrom`,
+          list: dm.allowFrom,
+        });
+      }
+      const groups = asObjectRecord(scope.account.groups);
+      if (groups) {
+        for (const [groupKey, groupRaw] of Object.entries(groups)) {
+          const group = asObjectRecord(groupRaw);
+          if (!group) {
+            continue;
+          }
+          lists.push({
+            pathLabel: `${scope.prefix}.groups.${groupKey}.users`,
+            list: group.users,
+          });
+        }
+      }
+      return lists;
+    },
+  });

package/src/gateway.ts

@@ -0,0 +1,63 @@
+import {
+  createAccountStatusSink,
+  runPassiveAccountLifecycle,
+} from "klaw/plugin-sdk/channel-lifecycle";
+import type { KlawConfig } from "klaw/plugin-sdk/config-contracts";
+import { createLazyRuntimeNamedExport } from "klaw/plugin-sdk/lazy-runtime";
+import type { ChannelAccountSnapshot } from "klaw/plugin-sdk/status-helpers";
+import type { ResolvedGoogleChatAccount } from "./accounts.js";
+import type { GoogleChatRuntimeEnv } from "./monitor-types.js";
+
+const loadGoogleChatChannelRuntime = createLazyRuntimeNamedExport(
+  () => import("./channel.runtime.js"),
+  "googleChatChannelRuntime",
+);
+
+export async function startGoogleChatGatewayAccount(ctx: {
+  account: ResolvedGoogleChatAccount;
+  cfg: KlawConfig;
+  runtime: GoogleChatRuntimeEnv;
+  abortSignal: AbortSignal;
+  setStatus: (next: ChannelAccountSnapshot) => void;
+  log?: {
+    info?: (message: string) => void;
+  };
+}): Promise<void> {
+  const account = ctx.account;
+  const statusSink = createAccountStatusSink({
+    accountId: account.accountId,
+    setStatus: ctx.setStatus,
+  });
+  ctx.log?.info?.(`[${account.accountId}] starting Google Chat webhook`);
+  const { resolveGoogleChatWebhookPath, startGoogleChatMonitor } =
+    await loadGoogleChatChannelRuntime();
+  statusSink({
+    running: true,
+    lastStartAt: Date.now(),
+    webhookPath: resolveGoogleChatWebhookPath({ account }),
+    audienceType: account.config.audienceType,
+    audience: account.config.audience,
+  });
+  await runPassiveAccountLifecycle({
+    abortSignal: ctx.abortSignal,
+    start: async () =>
+      await startGoogleChatMonitor({
+        account,
+        config: ctx.cfg,
+        runtime: ctx.runtime,
+        abortSignal: ctx.abortSignal,
+        webhookPath: account.config.webhookPath,
+        webhookUrl: account.config.webhookUrl,
+        statusSink,
+      }),
+    stop: async (unregister) => {
+      unregister?.();
+    },
+    onStop: async () => {
+      statusSink({
+        running: false,
+        lastStopAt: Date.now(),
+      });
+    },
+  });
+}