@chibitek/chibi 0.1.173 → 0.1.175

package/dist-server/openmausbot.js

@@ -20900,6 +20900,7 @@ var init_config = __esm({
       icm: external_exports.object({
         enabled: external_exports.boolean().optional(),
         aboutMePrefilled: external_exports.boolean().optional(),
+        // no longer read (About me syncs with PAW); kept so older configs parse
         path: external_exports.string().trim().max(4096).refine(
           (value) => !["\r", "\n", "\0"].some((character) => value.includes(character)),
           "Use a folder path without control characters"
@@ -30179,8 +30180,8 @@ var init_claude = __esm({
     DEFAULT_AUTOCOMPACT_TOKENS = 2e5;
     CLAUDE_FLAG_FLOORS = {
       "--strict-mcp-config": [1, 0, 60],
-      "--setting-sources": [1, 0, 122],
-      "--autocompact": [2, 1, 122],
+      "--setting-sources": [1, 0, 125],
+      "--autocompact": [2, 1, 221],
       // 2.1.267 is the first CLI that accepts it; below that the recorded prompt
       // simply is not refreshed, which is the pre-existing behaviour.
       "--system-prompt-snapshot": [2, 1, 267],

package/dist-server/pair-cli.js

@@ -20900,6 +20900,7 @@ var init_config = __esm({
       icm: external_exports.object({
         enabled: external_exports.boolean().optional(),
         aboutMePrefilled: external_exports.boolean().optional(),
+        // no longer read (About me syncs with PAW); kept so older configs parse
         path: external_exports.string().trim().max(4096).refine(
           (value) => !["\r", "\n", "\0"].some((character) => value.includes(character)),
           "Use a folder path without control characters"
@@ -30179,8 +30180,8 @@ var init_claude = __esm({
     DEFAULT_AUTOCOMPACT_TOKENS = 2e5;
     CLAUDE_FLAG_FLOORS = {
       "--strict-mcp-config": [1, 0, 60],
-      "--setting-sources": [1, 0, 122],
-      "--autocompact": [2, 1, 122],
+      "--setting-sources": [1, 0, 125],
+      "--autocompact": [2, 1, 221],
       // 2.1.267 is the first CLI that accepts it; below that the recorded prompt
       // simply is not refreshed, which is the pre-existing behaviour.
       "--system-prompt-snapshot": [2, 1, 267],

package/dist-server/server/about-me-sync.js

@@ -0,0 +1,172 @@
+// About me lives in up to three places: Atomic's profile (every bot, cloud
+// runs too), PAW me/about-me.md (local bots and CLI tools) and the person's
+// Nexus about_me (every AI signed in to Nexus). This keeps them the same:
+// an empty side is filled, an edit on one side reaches the others, and two
+// sides that disagree wait for the person to pick one in Settings > About me.
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { writeFileAtomic } from "./atomic.js";
+export const ABOUT_ME_SIDES = ["atomic", "paw", "nexus"];
+const norm = (text) => text.replace(/\r\n?/g, "\n").trim();
+/** One pass. `now` holds each reachable side's text (a side left out is
+ * skipped and caught up later); `seen` is what each side held after the
+ * last pass. A side whose text moved since then was edited, and a single
+ * edit reaches every other side. Two different edits, or a side seen for
+ * the first time that disagrees with the rest, are a conflict: nothing is
+ * written. `legacy` (an ICM "Who I am") fills everything when all sides are
+ * empty, and a profile still holding it counts as empty. */
+export function reconcileAboutMe(now, seen, legacy = "") {
+    const sides = ABOUT_ME_SIDES.filter((side) => now[side] !== undefined);
+    const text = (side) => (side === "atomic" && norm(legacy) && norm(now.atomic) === norm(legacy) ? "" : norm(now[side]));
+    const filled = sides.filter((side) => text(side));
+    const edited = filled.filter((side) => text(side) !== norm(seen[side] ?? ""));
+    const kept = filled.filter((side) => !edited.includes(side));
+    const firstContact = edited.some((side) => seen[side] === undefined) && kept.some((side) => text(side) !== text(edited[0]));
+    if (new Set(edited.map(text)).size > 1 || firstContact)
+        return { writes: {}, seen, conflict: filled };
+    const source = edited[0] ?? kept[0];
+    const target = source ? now[source] : legacy;
+    if (!norm(target))
+        return { writes: {}, seen, conflict: [] };
+    const writes = {};
+    for (const side of sides)
+        if (norm(now[side]) !== norm(target))
+            writes[side] = target;
+    return { writes, seen: { ...seen, ...Object.fromEntries(sides.map((side) => [side, norm(target)])) }, conflict: [] };
+}
+/** The person's About me in Nexus (about_me_get / about_me_set). */
+export function nexusAboutMe(client) {
+    if (!client)
+        return null;
+    return {
+        get: async () => {
+            const body = await client.call("about_me_get", {});
+            return typeof body.about_me === "string" ? body.about_me : "";
+        },
+        set: async (content) => { await client.call("about_me_set", { content }); },
+    };
+}
+/** How often a config read looks at Nexus again. */
+const NEXUS_EVERY_MS = 5 * 60_000;
+export class AboutMeSync {
+    deps;
+    path;
+    seen;
+    conflicts = {};
+    nexusAt = 0;
+    running = null;
+    constructor(deps) {
+        this.deps = deps;
+        this.path = join(deps.dataDir, "about-me-sync.json");
+        try {
+            const raw = JSON.parse(readFileSync(this.path, "utf8"));
+            this.seen = Object.fromEntries(ABOUT_ME_SIDES.filter((side) => typeof raw[side] === "string").map((side) => [side, raw[side]]));
+        }
+        catch {
+            this.seen = {};
+        }
+    }
+    /** The texts that disagree, by side, for Settings > About me. Empty when they agree. */
+    conflict() {
+        return { ...this.conflicts };
+    }
+    /** Atomic and PAW now, then Nexus; the app hears each time About me changes. */
+    sync(maxAgeMs) {
+        if (this.local())
+            this.deps.changed();
+        void this.all(maxAgeMs).then((changed) => changed && this.deps.changed());
+    }
+    /** Atomic and PAW, now. True when Atomic's About me changed. Never throws. */
+    local() {
+        const before = this.deps.profile.get();
+        try {
+            this.pass({ atomic: before, ...(this.deps.paw() ? { paw: this.deps.paw().get() } : {}) });
+        }
+        catch (error) {
+            console.warn(`[about-me] could not sync with PAW: ${error.message}`);
+        }
+        return this.deps.profile.get() !== before;
+    }
+    /** Every side, Nexus included. A config read passes the default and looks
+     * at Nexus at most every five minutes; a save passes 0. Never throws. */
+    async all(maxAgeMs = NEXUS_EVERY_MS) {
+        const clock = this.deps.now ?? Date.now;
+        if (this.running)
+            return this.running;
+        if (!this.deps.nexus() || clock() - this.nexusAt < maxAgeMs)
+            return this.local();
+        this.nexusAt = clock();
+        this.running = (async () => {
+            const nexus = this.deps.nexus();
+            const before = this.deps.profile.get();
+            let text;
+            try {
+                text = await nexus.get();
+            }
+            catch (error) {
+                console.warn(`[about-me] could not read Nexus: ${error.message}`);
+                this.local();
+                return this.deps.profile.get() !== before;
+            }
+            try {
+                const write = this.pass({ atomic: before, ...(this.deps.paw() ? { paw: this.deps.paw().get() } : {}), nexus: text });
+                if (write !== undefined) {
+                    await nexus.set(write);
+                    this.save({ ...this.seen, nexus: norm(write) });
+                }
+            }
+            catch (error) {
+                console.warn(`[about-me] could not sync with Nexus: ${error.message}`);
+            }
+            return this.deps.profile.get() !== before;
+        })().finally(() => { this.running = null; });
+        return this.running;
+    }
+    /** The person picked `side` in a conflict: its text goes everywhere.
+     * False when `side` is not one of the texts that disagree. */
+    async resolve(side) {
+        const text = ABOUT_ME_SIDES.includes(side) ? this.conflicts[side] : undefined;
+        if (text === undefined)
+            return false;
+        this.conflicts = {};
+        const paw = this.deps.paw();
+        if (norm(this.deps.profile.get()) !== norm(text))
+            this.deps.profile.set(text);
+        if (paw && norm(paw.get()) !== norm(text))
+            paw.set(text);
+        this.save({ ...this.seen, atomic: norm(text), ...(paw ? { paw: norm(text) } : {}) });
+        const nexus = this.deps.nexus();
+        if (nexus) {
+            await nexus.set(text);
+            this.save({ ...this.seen, nexus: norm(text) });
+        }
+        this.deps.changed();
+        return true;
+    }
+    /** Writes Atomic and PAW; returns the text Nexus should get, if any. */
+    pass(now) {
+        const result = reconcileAboutMe(now, this.seen, this.deps.legacy());
+        // a pass that could not see Nexus keeps a Nexus conflict on screen
+        this.conflicts = result.conflict.length || now.nexus !== undefined || !this.conflicts.nexus
+            ? Object.fromEntries(result.conflict.map((side) => [side, now[side]]))
+            : this.conflicts;
+        if (result.writes.paw !== undefined)
+            this.deps.paw()?.set(result.writes.paw);
+        if (result.writes.atomic !== undefined)
+            this.deps.profile.set(result.writes.atomic);
+        // Nexus counts as seen only once the write lands
+        this.save(result.writes.nexus === undefined ? result.seen : { ...result.seen, nexus: this.seen.nexus });
+        return result.writes.nexus;
+    }
+    save(next) {
+        if (JSON.stringify(next) === JSON.stringify(this.seen))
+            return;
+        this.seen = next;
+        try {
+            writeFileAtomic(this.path, `${JSON.stringify(next, null, 2)}\n`, { mode: 0o600 });
+        }
+        catch (error) {
+            console.warn(`[about-me] could not save sync state: ${error.message}`);
+        }
+    }
+}

package/dist-server/server/config.js

@@ -470,7 +470,7 @@ const appConfigSchema = z.object({
      * On unless `enabled` is false; an empty or absent path is ~/workspace/ICM. */
     icm: z.object({
         enabled: z.boolean().optional(),
-        aboutMePrefilled: z.boolean().optional(),
+        aboutMePrefilled: z.boolean().optional(), // no longer read (About me syncs with PAW); kept so older configs parse
         path: z.string().trim().max(4096).refine((value) => !["\r", "\n", "\0"].some((character) => value.includes(character)), "Use a folder path without control characters").optional(),
     }).strict().optional(),
     /** Settings > Memory (server/nexus-memory): always write session outcomes,

package/dist-server/server/dictation.js

@@ -84,6 +84,14 @@ export function checkCleanup(input, output) {
         if (tokens.filter((t) => kept.has(t)).length / tokens.length < 0.6)
             return { ok: false, reason: "overlap" };
     }
+    // a correction swaps a misheard word for the right one; words with nothing
+    // taken out for them were never said
+    const spoken = new Set(contentTokens(input));
+    const written = new Set(contentTokens(cleaned));
+    const added = [...written].filter((t) => !spoken.has(t)).length;
+    const removed = [...spoken].filter((t) => !written.has(t)).length;
+    if (added > removed + 1)
+        return { ok: false, reason: "added" };
     return { ok: true, text: cleaned };
 }
 export async function ask(provider, prompt, timeoutMs) {

package/dist-server/server/drivers/claude.js

@@ -259,12 +259,12 @@ const DEFAULT_AUTOCOMPACT_TOKENS = 200_000;
  *
  * Verified against the published binaries, not the changelog (which never
  * records `--autocompact`): `--strict-mcp-config` is present in 1.0.60 and
- * absent from 1.0.0; `--setting-sources` first appears in 1.0.122 (1.0.120
- * lacks it); `--autocompact` first appears in 2.1.122 (2.1.121 lacks it). */
+ * absent from 1.0.0; `--setting-sources` first appears in 1.0.125 (1.0.124
+ * lacks it); `--autocompact` first appears in 2.1.221 (2.1.220 lacks it). */
 export const CLAUDE_FLAG_FLOORS = {
     "--strict-mcp-config": [1, 0, 60],
-    "--setting-sources": [1, 0, 122],
-    "--autocompact": [2, 1, 122],
+    "--setting-sources": [1, 0, 125],
+    "--autocompact": [2, 1, 221],
     // 2.1.267 is the first CLI that accepts it; below that the recorded prompt
     // simply is not refreshed, which is the pre-existing behaviour.
     "--system-prompt-snapshot": [2, 1, 267],

package/dist-server/server/icm-context.js

@@ -145,25 +145,3 @@ export function icmAboutMeSummary(folder) {
     }
     return "";
 }
-/** The one-time config patch that fills an empty About me from Layer 0, or
- * null when there is nothing to do. An About me the person already wrote is
- * never replaced: the patch then only records that the check happened, so a
- * later edit, or clearing the field on purpose, is never refilled. */
-export function icmAboutMePrefill(cfg, home = homedir()) {
-    if (!icmEnabled(cfg) || cfg.icm?.aboutMePrefilled)
-        return null;
-    const folder = resolveIcmPath(cfg, home);
-    if (!icmFolderPresent(folder))
-        return null;
-    if (cfg.profile?.aboutMe?.trim())
-        return { icm: { aboutMePrefilled: true } };
-    const aboutMe = icmAboutMeSummary(folder);
-    return aboutMe ? { profile: { aboutMe }, icm: { aboutMePrefilled: true } } : null;
-}
-/** About me still holds exactly what was filled in from ICM. */
-export function aboutMeFromIcm(cfg, home = homedir()) {
-    const current = cfg.profile?.aboutMe?.trim();
-    if (!cfg.icm?.aboutMePrefilled || !current)
-        return false;
-    return current === icmAboutMeSummary(resolveIcmPath(cfg, home));
-}

package/dist-server/server/index.js

@@ -214,7 +214,8 @@ import { RTK_LAUNCHER_PATH, rtkLocalStatus } from "./rtk.js";
 import { withoutRtkLauncher } from "./rtk-rewrite.js";
 import { loadAddonSkillLibraries } from "./skill-addons.js";
 import { browserSkillCapabilities, loadBundledSkills, loadUserSkills, mergeSkills, renderSkillInstructions, selectBundledSkills } from "./skill-library.js";
-import { aboutMeFromIcm, icmAboutMePrefill, icmStatus, icmSystemPrompt } from "./icm-context.js";
+import { AboutMeSync, nexusAboutMe } from "./about-me-sync.js";
+import { icmAboutMeSummary, icmEnabled, icmStatus, icmSystemPrompt, resolveIcmPath } from "./icm-context.js";
 import { PawService } from "./paw/service.js";
 import { chibiFilingPrompt, parseFiledTaskId } from "./paw/change-requests.js";
 import { installedPlaybookInstructions } from "./installed-playbooks.js";
@@ -506,22 +507,6 @@ ensureNodeShim();
 // Extract the bundled npm (Resources/npm/npm-<version>.tgz) once, soon after
 // boot, so the first "Connect Claude" does not wait for it. It never throws.
 setTimeout(() => void bundledNpmCli(), 2_000).unref?.();
-/** Fill an empty About me from ICM Layer 0, once. True when config changed. */
-function prefillAboutMeFromIcm() {
-    const patch = icmAboutMePrefill(cfg);
-    if (!patch)
-        return false;
-    try {
-        saveConfig(patch);
-        Object.assign(cfg, loadConfig());
-        return true;
-    }
-    catch (error) {
-        console.warn(`[icm] could not fill About me: ${error.message}`);
-        return false;
-    }
-}
-prefillAboutMeFromIcm();
 // Who asked for the turn running (or last run) on each thread, read by the
 // usage ledger when it settles. It is set when a turn is ADMITTED, from the
 // message that started it — never when a message merely queues behind a
@@ -2468,9 +2453,15 @@ try {
 catch (error) {
     console.warn(`[paw] could not create the workspace: ${error.message}`);
 }
-function pawConfigStatus() {
-    return paw.summary();
-}
+const aboutMe = new AboutMeSync({
+    dataDir: DATA_DIR,
+    profile: { get: () => cfg.profile?.aboutMe ?? "", set: (text) => { saveConfig({ profile: { aboutMe: text.slice(0, 24_000) } }); Object.assign(cfg, loadConfig()); } },
+    paw: () => (paw.exists() ? { get: () => paw.aboutMe(), set: (text) => paw.setAboutMe(text) } : null),
+    nexus: () => nexusAboutMe(nexusMemory.getClient()),
+    legacy: () => (icmEnabled(cfg) ? icmAboutMeSummary(resolveIcmPath(cfg)) : ""),
+    changed: () => broadcast({ kind: "config", ...configStatus() }),
+});
+void aboutMe.all(0);
 /** The PAW section of a turn's system prompt. A cloud run cannot reach the
  * folder, so it gets none. */
 function pawPrompt(bot, request, runOn) {
@@ -14458,11 +14449,11 @@ function configStatus() {
         imageGen: avatarImageStatus(cfg),
         // not a secret — the sidebar shows it
         workspaceName: cfg.workspaceName ?? "",
-        profile: { name: cfg.profile?.name ?? "", email: cfg.profile?.email ?? "", aboutMe: cfg.profile?.aboutMe ?? "" },
+        profile: { name: cfg.profile?.name ?? "", email: cfg.profile?.email ?? "", aboutMe: cfg.profile?.aboutMe ?? "", aboutMeConflict: aboutMe.conflict() },
         // a folder path and whether it is there; nothing from inside it
-        icm: { ...icmStatus(cfg), aboutMeFromIcm: aboutMeFromIcm(cfg) },
+        icm: icmStatus(cfg),
         // where PAW lives and whether the interview ran; the files stay on disk
-        paw: pawConfigStatus(),
+        paw: paw.summary(),
         // the enrolled organisation's read-only desktop policy; null when not enrolled
         managedPolicy: managedPolicy.summary(),
         // whether this person sees Watch-Along (server/watch-along/access.ts)
@@ -14533,7 +14524,7 @@ function configForAccess(status, admin) {
         signIn: { admins: [], members: [] },
         vps: { configured: status.vps.configured, sshAlias: "" },
         profile: { name: status.profile.name, email: "" },
-        icm: { enabled: status.icm.enabled, found: status.icm.found, exists: status.icm.exists, path: "", defaultPath: "", aboutMeFromIcm: false },
+        icm: { enabled: status.icm.enabled, found: status.icm.found, exists: status.icm.exists, path: "", defaultPath: "" },
         paw: { ...status.paw, root: "" },
         browserProfiles: status.browserProfiles.map((profile) => Object.fromEntries(Object.entries(profile).filter(([key]) => key !== "partitionId"))),
     };
@@ -24245,6 +24236,7 @@ const handleRequest = async (req, res) => {
                     name: field("name", 80), role: field("role", 120), department: field("department", 80), company: field("company", 120),
                     goals: field("goals", 2_000), workingStyle: field("workingStyle", 2_000),
                 }, { chibitek: body?.chibitek === true });
+                aboutMe.sync(0);
                 broadcast({ kind: "config", ...configStatus() });
                 return json(res, 200, { ...status, aboutMe: paw.aboutMe() });
             }
@@ -24255,8 +24247,13 @@ const handleRequest = async (req, res) => {
                 if (!paw.exists())
                     await paw.ensure({ chibitek: cfg.onboarding?.setup?.chibitek === true });
                 paw.setAboutMe(body.text);
+                aboutMe.sync(0);
                 return json(res, 200, { ...paw.status(), aboutMe: paw.aboutMe() });
             }
+            if (method === "POST" && path === "/api/paw/about-me/resolve") {
+                const side = (await readBody(req))?.side;
+                return await aboutMe.resolve(String(side)) ? json(res, 200, { ok: true }) : json(res, 409, { error: "Nothing to choose: About me already agrees." });
+            }
             // Bot settings > Memory > Workspace knowledge
             if (method === "GET" && path === "/api/paw/suggestable") {
                 return json(res, 200, { files: paw.suggestable() });
@@ -24289,10 +24286,8 @@ const handleRequest = async (req, res) => {
             return json(res, 404, { error: "not found" });
         }
         if (method === "GET" && path === "/api/config") {
-            // an ICM folder created while the server runs (the setup chat) fills an
-            // empty About me the next time Settings or the app asks
-            if (prefillAboutMeFromIcm())
-                broadcast({ kind: "config", ...configStatus() });
+            // a me/about-me.md or Nexus edit, or a new ICM folder, reaches About me on a read
+            aboutMe.sync();
             return json(res, 200, configForAccess(configStatus(), auth.scopes.includes("admin")));
         }
         if ((method === "PUT" || method === "PATCH") && path === "/api/config") {
@@ -24698,9 +24693,9 @@ const handleRequest = async (req, res) => {
                         syncCredentialEnv(patch);
                         Object.assign(cfg, loadConfig());
                     }
-                    // a newly chosen or re-enabled ICM folder can fill an empty About me
-                    if (patch.icm)
-                        prefillAboutMeFromIcm();
+                    // an About me edit reaches PAW; a newly chosen ICM folder can fill an empty one
+                    if (patch.icm || patch.profile?.aboutMe !== undefined)
+                        aboutMe.sync(0);
                 }
                 catch (error) {
                     if (configWriteCommitted) {

package/dist-server/server/oauth-account-core.js

@@ -0,0 +1,153 @@
+// What every account tool shares: the account and call types, argument
+// basics, and one authenticated request to Google or Microsoft Graph.
+import { z } from "zod";
+import { OAUTH_PROVIDERS } from "../shared/oauth-providers.js";
+const HTTP_TIMEOUT_MS = 30_000;
+const MAX_RESULT_CHARS = 48_000;
+const MAX_JSON_BYTES = 4 * 1024 * 1024;
+export const MAX_DOWNLOAD_BYTES = 8 * 1024 * 1024;
+export const READS = { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true };
+export const CREATES = { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true };
+/** Sends mail or invitations to other people: cannot be taken back. */
+export const SENDS = { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: true };
+export const accountArg = { type: "string", description: "Email address of the account to use. Optional only when this bot has exactly one account of this provider." };
+export const EMAIL = /^[^\s@<>,;"]+@[^\s@<>,;"]+\.[^\s@<>,;"]+$/;
+export const noNewlines = (value) => !/[\r\n]/.test(value);
+export const base = z.object({ account: z.string().max(320).optional() });
+export class ToolInputError extends Error {
+}
+export function bounded(text, limit = MAX_RESULT_CHARS) {
+    return text.length <= limit ? text : `${text.slice(0, limit)}\n[truncated: ask for less]`;
+}
+export function addresses(value, field) {
+    if (value === undefined)
+        return [];
+    const list = (Array.isArray(value) ? value : value.split(",")).map((item) => item.trim()).filter(Boolean);
+    if (list.length > 50)
+        throw new ToolInputError(`${field}: at most 50 addresses`);
+    for (const item of list) {
+        if (!EMAIL.test(item))
+            throw new ToolInputError(`${field}: "${item.slice(0, 80)}" is not an email address`);
+    }
+    return list;
+}
+export class ProviderApiError extends Error {
+    status;
+    constructor(status, message) {
+        super(message);
+        this.status = status;
+    }
+}
+export async function readLimited(response, limit) {
+    const declared = Number(response.headers.get("content-length") ?? "0");
+    if (declared > limit) {
+        await response.body?.cancel().catch(() => { });
+        return null;
+    }
+    if (!response.body)
+        return Buffer.alloc(0);
+    const reader = response.body.getReader();
+    const chunks = [];
+    let size = 0;
+    for (;;) {
+        const { done, value } = await reader.read();
+        if (done)
+            break;
+        size += value.byteLength;
+        if (size > limit) {
+            await reader.cancel().catch(() => { });
+            return null;
+        }
+        chunks.push(value);
+    }
+    return Buffer.concat(chunks);
+}
+export function providerErrorMessage(body, status) {
+    const error = body?.error;
+    const message = typeof error === "string"
+        ? error
+        : error && typeof error === "object" && typeof error.message === "string"
+            ? error.message
+            : "";
+    return (message || `request failed with HTTP ${status}`).split(/\r?\n/)[0].slice(0, 300);
+}
+export async function call(ctx, account, url, init) {
+    const fetcher = ctx.fetch ?? fetch;
+    const { expect, ...request } = init;
+    for (let attempt = 0; attempt < 2; attempt += 1) {
+        const token = await ctx.accessToken(account.id);
+        const headers = new Headers(request.headers);
+        headers.set("authorization", `Bearer ${token}`);
+        if (!headers.has("accept") && expect === "json")
+            headers.set("accept", "application/json");
+        const response = await fetcher(url, { ...request, headers, signal: AbortSignal.timeout(HTTP_TIMEOUT_MS) });
+        if (response.status === 401 && attempt === 0) {
+            await response.body?.cancel().catch(() => { });
+            ctx.invalidate(account.id);
+            continue;
+        }
+        if (!response.ok) {
+            const raw = await readLimited(response, 64 * 1024);
+            let body = null;
+            try {
+                body = raw ? JSON.parse(raw.toString("utf8")) : null;
+            }
+            catch {
+                body = null;
+            }
+            const message = providerErrorMessage(body, response.status);
+            if (response.status === 403)
+                throw new ProviderApiError(403, `${account.email} does not allow this: ${message}`);
+            if (response.status === 404)
+                throw new ProviderApiError(404, `Not found in ${account.email}: ${message}`);
+            throw new ProviderApiError(response.status, `${OAUTH_PROVIDERS[account.provider].label} refused the request for ${account.email}: ${message}`);
+        }
+        if (expect === "none") {
+            await response.body?.cancel().catch(() => { });
+            return undefined;
+        }
+        const bytes = await readLimited(response, expect === "json" ? MAX_JSON_BYTES : MAX_DOWNLOAD_BYTES);
+        if (expect === "bytes")
+            return bytes;
+        if (!bytes)
+            throw new ProviderApiError(502, "The response was too large");
+        try {
+            return JSON.parse(bytes.toString("utf8"));
+        }
+        catch {
+            throw new ProviderApiError(502, "The service returned an unreadable response");
+        }
+    }
+    throw new ProviderApiError(401, `${account.email} needs to sign in again: open Settings → Accounts and connect it again.`);
+}
+export function parse(schema, value, what) {
+    const parsed = schema.safeParse(value);
+    if (!parsed.success)
+        throw new ProviderApiError(502, `Unexpected ${what} response`);
+    return parsed.data;
+}
+export function json(value) {
+    return JSON.stringify(value, null, 1);
+}
+export function htmlToText(html) {
+    return html
+        .replace(/<(script|style)[\s\S]*?<\/\1>/gi, "")
+        .replace(/<br\s*\/?>/gi, "\n")
+        .replace(/<\/(p|div|tr|li|h\d)>/gi, "\n")
+        .replace(/<[^>]+>/g, "")
+        .replace(/&nbsp;/g, " ")
+        .replace(/&amp;/g, "&")
+        .replace(/&lt;/g, "<")
+        .replace(/&gt;/g, ">")
+        .replace(/&quot;/g, '"')
+        .replace(/&#39;/g, "'")
+        .replace(/\n{3,}/g, "\n\n")
+        .trim();
+}
+export const GRAPH = "https://graph.microsoft.com/v1.0";
+export const graphRecipient = z.object({ emailAddress: z.object({ address: z.string().optional(), name: z.string().optional() }).optional() });
+export function recipient(value) {
+    const address = value?.emailAddress?.address;
+    const name = value?.emailAddress?.name;
+    return address ? (name && name !== address ? `${name} <${address}>` : address) : undefined;
+}