@chibitek/chibi 0.1.172 → 0.1.174

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;
+}

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

@@ -4,29 +4,15 @@
 // after the internal route has re-checked that this bot may use it.
 import { z } from "zod";
 import { OAUTH_PROVIDERS, } from "../shared/oauth-providers.js";
+import { CREATES, GRAPH, MAX_DOWNLOAD_BYTES, READS, SENDS, ToolInputError, accountArg, addresses, base, bounded, call, graphRecipient, htmlToText, json, noNewlines, parse, recipient, } from "./oauth-account-core.js";
 import { familyGranted, missingFamilies } from "./oauth-accounts.js";
+import { CALENDAR_RUNNERS, GOOGLE_CALENDAR_TOOLS, OUTLOOK_CALENDAR_TOOLS } from "./oauth-calendar-tools.js";
 import { officeKind, officeText } from "./office-text.js";
-const HTTP_TIMEOUT_MS = 30_000;
-const MAX_RESULT_CHARS = 48_000;
+export { ToolInputError } from "./oauth-account-core.js";
+export { graphDateTime } from "./oauth-calendar-tools.js";
 const MAX_BODY_CHARS = 20_000;
 const MAX_FILE_TEXT_CHARS = 40_000;
-const MAX_JSON_BYTES = 4 * 1024 * 1024;
-const MAX_DOWNLOAD_BYTES = 8 * 1024 * 1024;
-const READS = { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true };
-const CREATES = { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true };
-/** Sends mail or invitations to other people: cannot be taken back. */
-const SENDS = { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: true };
-const accountArg = { type: "string", description: "Email address of the account to use. Optional only when this bot has exactly one account of this provider." };
 const emailList = z.union([z.string(), z.array(z.string()).max(50)]);
-const EMAIL = /^[^\s@<>,;"]+@[^\s@<>,;"]+\.[^\s@<>,;"]+$/;
-const noNewlines = (value) => !/[\r\n]/.test(value);
-function isoInstant(value) {
-    return /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}(?::\d{2}(?:\.\d+)?)?(?:Z|[+-]\d{2}:\d{2})$/.test(value) && Number.isFinite(Date.parse(value));
-}
-function isoDateOrTime(value) {
-    return /^\d{4}-\d{2}-\d{2}$/.test(value) || /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}(?::\d{2}(?:\.\d+)?)?(?:Z|[+-]\d{2}:\d{2})?$/.test(value);
-}
-const base = z.object({ account: z.string().max(320).optional() });
 const searchArgs = base.extend({ q: z.string().min(1).max(500), max: z.number().int().min(1).max(25).optional() }).strict();
 const idArgs = (key) => base.extend({ [key]: z.string().min(1).max(512).regex(/^[A-Za-z0-9!_.=+\-/~:]+$/, "not a valid id") }).strict();
 const draftArgs = base.extend({
@@ -35,22 +21,6 @@ const draftArgs = base.extend({
     body: z.string().max(200_000),
     cc: emailList.optional(),
 }).strict();
-const listEventsArgs = base.extend({
-    timeMin: z.string().refine(isoInstant, "timeMin must be an ISO 8601 date-time with a time zone, e.g. 2026-10-01T00:00:00Z"),
-    timeMax: z.string().refine(isoInstant, "timeMax must be an ISO 8601 date-time with a time zone, e.g. 2026-10-08T00:00:00Z"),
-    calendarId: z.string().min(1).max(320).optional(),
-    max: z.number().int().min(1).max(100).optional(),
-}).strict();
-const createEventArgs = base.extend({
-    summary: z.string().min(1).max(1_000).refine(noNewlines, "summary must be one line"),
-    start: z.string().refine(isoDateOrTime, "start must be YYYY-MM-DD or an ISO 8601 date-time"),
-    end: z.string().refine(isoDateOrTime, "end must be YYYY-MM-DD or an ISO 8601 date-time"),
-    timeZone: z.string().min(1).max(64).regex(/^[A-Za-z0-9_+\-/ ]+$/).optional(),
-    description: z.string().max(8_000).optional(),
-    location: z.string().max(1_000).optional(),
-    attendees: z.array(z.string()).max(50).optional(),
-    calendarId: z.string().min(1).max(320).optional(),
-}).strict();
 const listAccountsArgs = z.object({}).strict();
 const searchSchema = (what) => ({
     type: "object",
@@ -71,50 +41,20 @@ const draftSchema = {
     required: ["to", "subject", "body"],
     additionalProperties: false,
 };
-const listEventsSchema = (withCalendar) => ({
-    type: "object",
-    properties: {
-        account: accountArg,
-        timeMin: { type: "string", description: "Start of the window, ISO 8601 with a time zone (e.g. 2026-10-01T00:00:00Z)." },
-        timeMax: { type: "string", description: "End of the window, ISO 8601 with a time zone." },
-        ...(withCalendar ? { calendarId: { type: "string", description: "Calendar id; defaults to the primary calendar." } } : {}),
-        max: { type: "integer", minimum: 1, maximum: 100, description: "Most events to return (default 25)." },
-    },
-    required: ["timeMin", "timeMax"],
-    additionalProperties: false,
-});
-const createEventSchema = (withCalendar) => ({
-    type: "object",
-    properties: {
-        account: accountArg,
-        summary: { type: "string", description: "Event title." },
-        start: { type: "string", description: "YYYY-MM-DD for an all-day event, or an ISO 8601 date-time. Without an offset, pass timeZone." },
-        end: { type: "string", description: "Same format as start. For all-day events this is the day after the last day." },
-        timeZone: { type: "string", description: "IANA time zone such as America/Los_Angeles, used when start/end have no offset." },
-        description: { type: "string" },
-        location: { type: "string" },
-        attendees: { type: "array", items: { type: "string" }, description: "Guest email addresses. They receive an invitation." },
-        ...(withCalendar ? { calendarId: { type: "string", description: "Calendar id; defaults to the primary calendar." } } : {}),
-    },
-    required: ["summary", "start", "end"],
-    additionalProperties: false,
-});
 export const ACCOUNT_TOOLS = [
     { name: "list_accounts", provider: null, description: "List the Google and Microsoft accounts this bot may use, by email.", inputSchema: { type: "object", properties: {}, additionalProperties: false }, annotations: READS, args: listAccountsArgs },
     { name: "gmail_search", provider: "google", family: "gmail", description: "Search Gmail with Gmail search syntax (e.g. from:alex newer_than:7d). Returns message ids, senders, subjects, dates and snippets.", inputSchema: searchSchema("Gmail search query."), annotations: READS, args: searchArgs },
     { name: "gmail_read", provider: "google", family: "gmail", description: "Read one Gmail message by id: headers, plain-text body and attachment names.", inputSchema: idSchema("id", "Message id from gmail_search."), annotations: READS, args: idArgs("id") },
     { name: "gmail_create_draft", provider: "google", family: "gmailSend", description: "Create a plain-text Gmail draft. Nothing is sent until gmail_send_draft.", inputSchema: draftSchema, annotations: CREATES, args: draftArgs },
     { name: "gmail_send_draft", provider: "google", family: "gmailSend", description: "Send an existing Gmail draft by its draft id.", inputSchema: idSchema("draftId", "Draft id from gmail_create_draft."), annotations: SENDS, args: idArgs("draftId") },
-    { name: "calendar_list_events", provider: "google", family: "calendar", description: "List Google Calendar events between two times.", inputSchema: listEventsSchema(true), annotations: READS, args: listEventsArgs },
-    { name: "calendar_create_event", provider: "google", family: "calendar", description: "Create a Google Calendar event. Attendees receive an invitation.", inputSchema: createEventSchema(true), annotations: SENDS, args: createEventArgs },
+    ...GOOGLE_CALENDAR_TOOLS,
     { name: "drive_search", provider: "google", family: "drive", description: "Search Google Drive files by words in their name or content.", inputSchema: searchSchema("Words to look for."), annotations: READS, args: searchArgs },
     { name: "drive_read", provider: "google", family: "drive", description: "Read a Google Drive file by id: text for Docs, Sheets (CSV), Slides, Office and text files; details and a link otherwise.", inputSchema: idSchema("fileId", "File id from drive_search."), annotations: READS, args: idArgs("fileId") },
     { name: "outlook_search", provider: "microsoft", family: "outlook", description: "Search Outlook mail by words (sender, subject, body). Returns message ids, senders, subjects, dates and previews.", inputSchema: searchSchema("Words to search for."), annotations: READS, args: searchArgs },
     { name: "outlook_read", provider: "microsoft", family: "outlook", description: "Read one Outlook message by id: headers and plain-text body.", inputSchema: idSchema("id", "Message id from outlook_search."), annotations: READS, args: idArgs("id") },
     { name: "outlook_create_draft", provider: "microsoft", family: "outlook", description: "Create a plain-text Outlook draft. Nothing is sent until outlook_send_draft.", inputSchema: draftSchema, annotations: CREATES, args: draftArgs },
     { name: "outlook_send_draft", provider: "microsoft", family: "outlook", description: "Send an existing Outlook draft by its id.", inputSchema: idSchema("draftId", "Draft id from outlook_create_draft."), annotations: SENDS, args: idArgs("draftId") },
-    { name: "outlook_calendar_list_events", provider: "microsoft", family: "outlookCalendar", description: "List Outlook calendar events between two times (times are returned in UTC).", inputSchema: listEventsSchema(false), annotations: READS, args: listEventsArgs.omit({ calendarId: true }) },
-    { name: "outlook_calendar_create_event", provider: "microsoft", family: "outlookCalendar", description: "Create an Outlook calendar event. Attendees receive an invitation.", inputSchema: createEventSchema(false), annotations: SENDS, args: createEventArgs.omit({ calendarId: true }) },
+    ...OUTLOOK_CALENDAR_TOOLS,
     { name: "onedrive_search", provider: "microsoft", family: "onedrive", description: "Search OneDrive files by words in their name or content.", inputSchema: searchSchema("Words to look for."), annotations: READS, args: searchArgs },
     { name: "onedrive_read", provider: "microsoft", family: "onedrive", description: "Read a OneDrive file by id: text for small text and Office files, details and a link otherwise.", inputSchema: idSchema("fileId", "File id from onedrive_search."), annotations: READS, args: idArgs("fileId") },
 ];
@@ -129,11 +69,6 @@ export function accountToolList(providers) {
 export function isReadOnlyAccountTool(name) {
     return TOOL_BY_NAME.get(name)?.annotations.readOnlyHint === true;
 }
-export class ToolInputError extends Error {
-}
-function bounded(text, limit = MAX_RESULT_CHARS) {
-    return text.length <= limit ? text : `${text.slice(0, limit)}\n[truncated: ask for less]`;
-}
 function describeIssues(error) {
     return error.issues.slice(0, 5).map((issue) => `${issue.path.join(".") || "arguments"}: ${issue.message}`).join("; ");
 }
@@ -154,134 +89,9 @@ export function resolveAccount(provider, allowed, requested) {
         return candidates[0];
     throw new ToolInputError(`Pass account: this bot has more than one ${label} account (${candidates.map((account) => account.email).join(", ")}).`);
 }
-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;
-}
-class ProviderApiError extends Error {
-    status;
-    constructor(status, message) {
-        super(message);
-        this.status = status;
-    }
-}
-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);
-}
-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);
-}
-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.`);
-}
-function parse(schema, value, what) {
-    const parsed = schema.safeParse(value);
-    if (!parsed.success)
-        throw new ProviderApiError(502, `Unexpected ${what} response`);
-    return parsed.data;
-}
-function json(value) {
-    return JSON.stringify(value, null, 1);
-}
 function decodeBase64Url(data) {
     return data ? Buffer.from(data, "base64url").toString("utf8") : "";
 }
-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();
-}
 function encodeHeader(value) {
     return /^[\x20-\x7e]*$/.test(value) ? value : `=?UTF-8?B?${Buffer.from(value, "utf8").toString("base64")}?=`;
 }
@@ -317,7 +127,6 @@ function readable(name, mimeType) {
 }
 // ── Google ────────────────────────────────────────────────────────────────
 const GMAIL = "https://gmail.googleapis.com/gmail/v1/users/me";
-const CALENDAR = "https://www.googleapis.com/calendar/v3";
 const DRIVE = "https://www.googleapis.com/drive/v3";
 const gmailPartSchema = z.lazy(() => z.object({
     mimeType: z.string().optional(),
@@ -405,69 +214,6 @@ async function gmailSendDraft(ctx, account, args) {
     const sent = parse(z.object({ id: z.string(), threadId: z.string().optional() }), await call(ctx, account, `${GMAIL}/drafts/send`, { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify({ id: args.draftId }), expect: "json" }), "Gmail send");
     return json({ account: account.email, sent: true, messageId: sent.id, threadId: sent.threadId });
 }
-const googleEventSchema = z.object({
-    id: z.string(),
-    summary: z.string().optional(),
-    description: z.string().optional(),
-    location: z.string().optional(),
-    status: z.string().optional(),
-    htmlLink: z.string().optional(),
-    start: z.object({ dateTime: z.string().optional(), date: z.string().optional(), timeZone: z.string().optional() }).optional(),
-    end: z.object({ dateTime: z.string().optional(), date: z.string().optional(), timeZone: z.string().optional() }).optional(),
-    organizer: z.object({ email: z.string().optional() }).optional(),
-    attendees: z.array(z.object({ email: z.string().optional(), responseStatus: z.string().optional() })).optional(),
-});
-function googleEvent(event) {
-    return {
-        id: event.id,
-        summary: event.summary,
-        start: event.start?.dateTime ?? event.start?.date,
-        end: event.end?.dateTime ?? event.end?.date,
-        location: event.location,
-        organizer: event.organizer?.email,
-        attendees: event.attendees?.map((attendee) => `${attendee.email ?? ""}${attendee.responseStatus ? ` (${attendee.responseStatus})` : ""}`),
-        description: event.description ? bounded(event.description, 2_000) : undefined,
-        link: event.htmlLink,
-    };
-}
-async function calendarListEvents(ctx, account, args) {
-    const calendarId = encodeURIComponent(args.calendarId ?? "primary");
-    const query = new URLSearchParams({ timeMin: args.timeMin, timeMax: args.timeMax, singleEvents: "true", orderBy: "startTime", maxResults: String(args.max ?? 25) });
-    const list = parse(z.object({ items: z.array(googleEventSchema).optional(), timeZone: z.string().optional() }), await call(ctx, account, `${CALENDAR}/calendars/${calendarId}/events?${query}`, { expect: "json" }), "Calendar");
-    return json({ account: account.email, timeZone: list.timeZone, events: (list.items ?? []).map(googleEvent) });
-}
-function eventTime(value, timeZone, field) {
-    if (/^\d{4}-\d{2}-\d{2}$/.test(value))
-        return { allDay: true, date: value };
-    const hasOffset = /(?:Z|[+-]\d{2}:\d{2})$/.test(value);
-    if (!hasOffset && !timeZone)
-        throw new ToolInputError(`${field}: add a UTC offset (e.g. 2026-10-01T15:00:00-07:00) or pass timeZone`);
-    return { allDay: false, dateTime: value, hasOffset };
-}
-async function calendarCreateEvent(ctx, account, args) {
-    const start = eventTime(args.start, args.timeZone, "start");
-    const end = eventTime(args.end, args.timeZone, "end");
-    if (start.allDay !== end.allDay)
-        throw new ToolInputError("start and end must both be dates or both be date-times");
-    const attendees = addresses(args.attendees, "attendees");
-    const time = (value) => value.allDay
-        ? { date: value.date }
-        : { dateTime: value.dateTime, ...(args.timeZone ? { timeZone: args.timeZone } : {}) };
-    const body = {
-        summary: args.summary,
-        ...(args.description ? { description: args.description } : {}),
-        ...(args.location ? { location: args.location } : {}),
-        start: time(start),
-        end: time(end),
-        ...(attendees.length ? { attendees: attendees.map((email) => ({ email })) } : {}),
-    };
-    const calendarId = encodeURIComponent(args.calendarId ?? "primary");
-    const query = new URLSearchParams({ sendUpdates: attendees.length ? "all" : "none" });
-    const created = parse(googleEventSchema, await call(ctx, account, `${CALENDAR}/calendars/${calendarId}/events?${query}`, {
-        method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify(body), expect: "json",
-    }), "Calendar");
-    return json({ account: account.email, created: googleEvent(created) });
-}
 const driveFileSchema = z.object({
     id: z.string(),
     name: z.string().optional(),
@@ -516,8 +262,6 @@ async function driveRead(ctx, account, args) {
         : { ...details, text: bounded(text, MAX_FILE_TEXT_CHARS) });
 }
 // ── Microsoft Graph ───────────────────────────────────────────────────────
-const GRAPH = "https://graph.microsoft.com/v1.0";
-const graphRecipient = z.object({ emailAddress: z.object({ address: z.string().optional(), name: z.string().optional() }).optional() });
 const graphMessageSchema = z.object({
     id: z.string(),
     conversationId: z.string().optional(),
@@ -531,11 +275,6 @@ const graphMessageSchema = z.object({
     hasAttachments: z.boolean().optional(),
     body: z.object({ contentType: z.string().optional(), content: z.string().optional() }).optional(),
 });
-function recipient(value) {
-    const address = value?.emailAddress?.address;
-    const name = value?.emailAddress?.name;
-    return address ? (name && name !== address ? `${name} <${address}>` : address) : undefined;
-}
 async function outlookSearch(ctx, account, args) {
     const query = new URLSearchParams({
         $search: `"${args.q.replace(/["\\]/g, " ")}"`,
@@ -598,83 +337,6 @@ async function outlookSendDraft(ctx, account, args) {
     await call(ctx, account, `${GRAPH}/me/messages/${encodeURIComponent(args.draftId)}/send`, { method: "POST", expect: "none" });
     return json({ account: account.email, sent: true, draftId: args.draftId });
 }
-const graphTime = z.object({ dateTime: z.string().optional(), timeZone: z.string().optional() });
-const graphEventSchema = z.object({
-    id: z.string(),
-    subject: z.string().nullable().optional(),
-    start: graphTime.optional(),
-    end: graphTime.optional(),
-    isAllDay: z.boolean().optional(),
-    location: z.object({ displayName: z.string().optional() }).nullable().optional(),
-    organizer: graphRecipient.nullable().optional(),
-    attendees: z.array(graphRecipient.extend({ status: z.object({ response: z.string().optional() }).optional() })).optional(),
-    webLink: z.string().optional(),
-    bodyPreview: z.string().optional(),
-});
-function graphEvent(event) {
-    return {
-        id: event.id,
-        summary: event.subject,
-        start: event.start?.dateTime ? `${event.start.dateTime}${event.start.timeZone === "UTC" ? "Z" : ` (${event.start.timeZone ?? ""})`}` : undefined,
-        end: event.end?.dateTime ? `${event.end.dateTime}${event.end.timeZone === "UTC" ? "Z" : ` (${event.end.timeZone ?? ""})`}` : undefined,
-        allDay: event.isAllDay,
-        location: event.location?.displayName || undefined,
-        organizer: recipient(event.organizer),
-        attendees: event.attendees?.map((attendee) => `${recipient(attendee) ?? ""}${attendee.status?.response ? ` (${attendee.status.response})` : ""}`),
-        preview: event.bodyPreview ? bounded(event.bodyPreview, 1_000) : undefined,
-        link: event.webLink,
-    };
-}
-async function outlookListEvents(ctx, account, args) {
-    const query = new URLSearchParams({
-        startDateTime: new Date(args.timeMin).toISOString(),
-        endDateTime: new Date(args.timeMax).toISOString(),
-        $top: String(args.max ?? 25),
-        $orderby: "start/dateTime",
-        $select: "id,subject,start,end,isAllDay,location,organizer,attendees,webLink,bodyPreview",
-    });
-    const list = parse(z.object({ value: z.array(graphEventSchema) }), await call(ctx, account, `${GRAPH}/me/calendarView?${query}`, {
-        headers: { prefer: 'outlook.timezone="UTC"' }, expect: "json",
-    }), "Outlook calendar");
-    return json({ account: account.email, timeZone: "UTC", events: list.value.map(graphEvent) });
-}
-/** Graph wants a wall-clock time plus a zone: a time with an offset is
- * converted to UTC, one without keeps the zone the bot named. */
-export function graphDateTime(value, timeZone, field) {
-    if (/^\d{4}-\d{2}-\d{2}$/.test(value))
-        return { dateTime: `${value}T00:00:00`, timeZone: timeZone ?? "UTC", allDay: true };
-    if (/(?:Z|[+-]\d{2}:\d{2})$/.test(value)) {
-        const parsed = Date.parse(value);
-        if (!Number.isFinite(parsed))
-            throw new ToolInputError(`${field}: not a valid date-time`);
-        return { dateTime: new Date(parsed).toISOString().replace(/\.\d{3}Z$/, ""), timeZone: "UTC", allDay: false };
-    }
-    if (!timeZone)
-        throw new ToolInputError(`${field}: add a UTC offset (e.g. 2026-10-01T15:00:00-07:00) or pass timeZone`);
-    return { dateTime: value, timeZone, allDay: false };
-}
-async function outlookCreateEvent(ctx, account, args) {
-    const start = graphDateTime(args.start, args.timeZone, "start");
-    const end = graphDateTime(args.end, args.timeZone, "end");
-    if (start.allDay !== end.allDay)
-        throw new ToolInputError("start and end must both be dates or both be date-times");
-    const attendees = addresses(args.attendees, "attendees");
-    const created = parse(graphEventSchema, await call(ctx, account, `${GRAPH}/me/events`, {
-        method: "POST",
-        headers: { "content-type": "application/json", prefer: 'outlook.timezone="UTC"' },
-        body: JSON.stringify({
-            subject: args.summary,
-            ...(args.description ? { body: { contentType: "Text", content: args.description } } : {}),
-            start: { dateTime: start.dateTime, timeZone: start.timeZone },
-            end: { dateTime: end.dateTime, timeZone: end.timeZone },
-            ...(start.allDay ? { isAllDay: true } : {}),
-            ...(args.location ? { location: { displayName: args.location } } : {}),
-            ...(attendees.length ? { attendees: attendees.map((address) => ({ emailAddress: { address }, type: "required" })) } : {}),
-        }),
-        expect: "json",
-    }), "Outlook calendar");
-    return json({ account: account.email, created: graphEvent(created) });
-}
 const driveItemSchema = z.object({
     id: z.string(),
     name: z.string().optional(),
@@ -713,16 +375,13 @@ const RUNNERS = {
     gmail_read: gmailRead,
     gmail_create_draft: gmailCreateDraft,
     gmail_send_draft: gmailSendDraft,
-    calendar_list_events: calendarListEvents,
-    calendar_create_event: calendarCreateEvent,
+    ...CALENDAR_RUNNERS,
     drive_search: driveSearch,
     drive_read: driveRead,
     outlook_search: outlookSearch,
     outlook_read: outlookRead,
     outlook_create_draft: outlookCreateDraft,
     outlook_send_draft: outlookSendDraft,
-    outlook_calendar_list_events: outlookListEvents,
-    outlook_calendar_create_event: outlookCreateEvent,
     onedrive_search: onedriveSearch,
     onedrive_read: onedriveRead,
 };