runline 0.7.6 → 0.8.0

package/dist/plugins/googleImage/src/index.js

@@ -6,15 +6,20 @@
  * API key. Kept under the `googleImage` namespace so it doesn't
  * collide with `googleDrive`, `googleDocs`, etc.
  *
- *   await googleImage.image.create({ prompt: "a watercolor fox" })
- *   await googleImage.image.create({
- *     prompt: "edit: make the sky stormier",
- *     model: "gemini-3-pro-image-preview",
- *   })
+ *   const { images } = await googleImage.image.create({ prompt: "a watercolor fox" })
+ *   // images[0].path -> "/tmp/googleImage-….png"
+ *
+ * Generated images are written to disk and the action returns their file
+ * `path`s — never raw base64, which bloats the agent context and is
+ * stripped before delivery. Hand each `path` to the host's file-sending
+ * tool (e.g. send_file) to deliver the image.
  *
  * Nano Banana supports conversational editing — chain prompts in
  * follow-up calls and it'll keep iterating on the last image.
  */
+import { writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
 const BASE = "https://generativelanguage.googleapis.com/v1beta/models";
 export default function googleImage(rl) {
     rl.setName("googleImage");
@@ -28,7 +33,7 @@ export default function googleImage(rl) {
         },
     });
     rl.registerAction("image.create", {
-        description: "Generate an image with Google's Gemini image models (Nano Banana / Imagen). Returns base64 bytes per candidate.",
+        description: "Generate an image with Google's Gemini image models (Nano Banana / Imagen). Writes the image(s) to disk and returns their file `path`s — not base64. Deliver each image to the user with send_file using its `path`.",
         inputSchema: {
             prompt: {
                 type: "string",
@@ -40,6 +45,11 @@ export default function googleImage(rl) {
                 required: false,
                 description: "gemini-2.5-flash-image (Nano Banana, default) | gemini-3-pro-image-preview | gemini-3.1-flash-image-preview",
             },
+            saveDir: {
+                type: "string",
+                required: false,
+                description: "Directory to write the image file(s) into. Defaults to the OS temp dir.",
+            },
         },
         async execute(input, ctx) {
             const p = (input ?? {});
@@ -62,18 +72,27 @@ export default function googleImage(rl) {
                 throw new Error(`Google API error ${res.status}: ${await res.text()}`);
             }
             const data = (await res.json());
+            const dir = (typeof p.saveDir === "string" && p.saveDir.trim()) || tmpdir();
+            const stamp = Date.now();
             const images = [];
             for (const candidate of data.candidates ?? []) {
                 for (const part of candidate.content?.parts ?? []) {
                     if (part.inlineData?.data) {
-                        images.push({
-                            base64: part.inlineData.data,
-                            mimeType: part.inlineData.mimeType ?? "image/png",
-                        });
+                        const mimeType = part.inlineData.mimeType ?? "image/png";
+                        const ext = mimeType.includes("jpeg") ? "jpg" : mimeType.split("/")[1] || "png";
+                        const bytes = Buffer.from(part.inlineData.data, "base64");
+                        const path = join(dir, `googleImage-${stamp}-${images.length}.${ext}`);
+                        writeFileSync(path, bytes);
+                        images.push({ path, mimeType, byteLength: bytes.length });
                     }
                 }
             }
-            return { provider: "googleImage", model, images };
+            return {
+                provider: "googleImage",
+                model,
+                images,
+                note: "Image(s) written to disk. Deliver each to the user with send_file using its `path`.",
+            };
         },
     });
 }

package/dist/plugins/googleSheets/src/index.js

@@ -313,6 +313,17 @@ const SCOPES = [
     "https://www.googleapis.com/auth/spreadsheets",
     "https://www.googleapis.com/auth/drive.file",
 ];
+function a1RangeToGridRange(a1, sheetId) {
+    // Strip optional 'Sheet!' prefix
+    const m = a1.match(/^(?:[^!]+!)?([A-Z]+)(\d+):([A-Z]+)(\d+)$/i);
+    if (!m)
+        throw new Error(`a1RangeToGridRange: cannot parse ${a1}; expected A1 form like A1:D20`);
+    const startCol = columnLetterToNumber(m[1]) - 1;
+    const startRow = parseInt(m[2], 10) - 1;
+    const endCol = columnLetterToNumber(m[3]);
+    const endRow = parseInt(m[4], 10);
+    return { sheetId, startRowIndex: startRow, endRowIndex: endRow, startColumnIndex: startCol, endColumnIndex: endCol };
+}
 export default function googleSheets(rl) {
     rl.setName("googleSheets");
     rl.setVersion("0.1.0");
@@ -899,4 +910,268 @@ async function runUpdateOrUpsert(ctx, p, upsert) {
         appended: prepared.appendData.length,
         newColumns: prepared.newColumns,
     };
+    // ─── Charts ─────────────────────────────────────────────────────
+    rl.registerAction("chart.add", {
+        description: "Embed a chart on a sheet. Minimal signature: type ('COLUMN'|'BAR'|'LINE'|'AREA'|'PIE'|'SCATTER'|'COMBO'), data source (sheet name + A1 range), and target anchor cell. For full control pass a raw `chartSpec` object instead.",
+        inputSchema: {
+            spreadsheetId: { type: "string", required: true },
+            title: { type: "string", required: false },
+            type: { type: "string", required: false, description: "Basic chart type. Default COLUMN. Ignored when `chartSpec` is provided." },
+            sourceSheet: { type: "string", required: false, description: "Sheet name holding the source range. Ignored when `chartSpec` is provided." },
+            sourceRange: { type: "string", required: false, description: "A1 range on `sourceSheet`, e.g. 'A1:D20'. Ignored when `chartSpec` is provided." },
+            legendPosition: { type: "string", required: false, description: "BOTTOM_LEGEND | TOP_LEGEND | RIGHT_LEGEND | LEFT_LEGEND | NO_LEGEND. Default BOTTOM_LEGEND." },
+            stackedType: { type: "string", required: false, description: "STACKED | PERCENT_STACKED — for COLUMN/BAR/AREA." },
+            anchorSheet: { type: "string", required: true, description: "Sheet to place the chart on." },
+            anchorRow: { type: "number", required: false, default: 0 },
+            anchorColumn: { type: "number", required: false, default: 0 },
+            widthPx: { type: "number", required: false, default: 600 },
+            heightPx: { type: "number", required: false, default: 371 },
+            chartSpec: { type: "object", required: false, description: "Raw ChartSpec object; bypasses the simple type+source builder." },
+        },
+        async execute(input, ctx) {
+            const p = (input ?? {});
+            const spreadsheetId = p.spreadsheetId;
+            const anchorSheetId = await resolveSheetId(ctx, spreadsheetId, p.anchorSheet);
+            let spec;
+            if (p.chartSpec) {
+                spec = p.chartSpec;
+            }
+            else {
+                const sourceSheetId = await resolveSheetId(ctx, spreadsheetId, p.sourceSheet);
+                const grid = a1RangeToGridRange(p.sourceRange, sourceSheetId);
+                spec = {
+                    title: p.title,
+                    basicChart: {
+                        chartType: p.type ?? "COLUMN",
+                        legendPosition: p.legendPosition ?? "BOTTOM_LEGEND",
+                        stackedType: p.stackedType,
+                        headerCount: 1,
+                        domains: [{ domain: { sourceRange: { sources: [{
+                                                sheetId: grid.sheetId, startRowIndex: grid.startRowIndex, endRowIndex: grid.endRowIndex,
+                                                startColumnIndex: grid.startColumnIndex, endColumnIndex: grid.startColumnIndex + 1,
+                                            }] } } }],
+                        series: [{ series: { sourceRange: { sources: [{
+                                                sheetId: grid.sheetId, startRowIndex: grid.startRowIndex, endRowIndex: grid.endRowIndex,
+                                                startColumnIndex: grid.startColumnIndex + 1, endColumnIndex: grid.endColumnIndex,
+                                            }] } }, targetAxis: "LEFT_AXIS" }],
+                    },
+                };
+            }
+            const req = {
+                addChart: {
+                    chart: {
+                        spec,
+                        position: {
+                            overlayPosition: {
+                                anchorCell: { sheetId: anchorSheetId, rowIndex: p.anchorRow ?? 0, columnIndex: p.anchorColumn ?? 0 },
+                                widthPixels: p.widthPx ?? 600,
+                                heightPixels: p.heightPx ?? 371,
+                            },
+                        },
+                    },
+                },
+            };
+            return spreadsheetBatchUpdate(ctx, spreadsheetId, [req]);
+        },
+    });
+    rl.registerAction("chart.update", {
+        description: "Update an existing chart's spec by chartId.",
+        inputSchema: {
+            spreadsheetId: { type: "string", required: true },
+            chartId: { type: "number", required: true },
+            chartSpec: { type: "object", required: true },
+            fields: { type: "string", required: false, default: "*" },
+        },
+        async execute(input, ctx) {
+            const p = (input ?? {});
+            return spreadsheetBatchUpdate(ctx, p.spreadsheetId, [
+                {
+                    updateChartSpec: {
+                        chartId: p.chartId,
+                        spec: p.chartSpec,
+                        fields: p.fields ?? "*",
+                    },
+                },
+            ]);
+        },
+    });
+    rl.registerAction("chart.delete", {
+        description: "Delete a chart by its embedded-object id.",
+        inputSchema: {
+            spreadsheetId: { type: "string", required: true },
+            chartId: { type: "number", required: true },
+        },
+        async execute(input, ctx) {
+            const p = (input ?? {});
+            return spreadsheetBatchUpdate(ctx, p.spreadsheetId, [
+                { deleteEmbeddedObject: { objectId: p.chartId } },
+            ]);
+        },
+    });
+    // ─── Named ranges ───────────────────────────────────────────────
+    rl.registerAction("namedRange.add", {
+        description: "Create a named range on a sheet (so formulas can reference it by name).",
+        inputSchema: {
+            spreadsheetId: { type: "string", required: true },
+            name: { type: "string", required: true },
+            sheet: { type: "string", required: true },
+            range: { type: "string", required: true, description: "A1 range on `sheet`, e.g. 'A1:D20'." },
+        },
+        async execute(input, ctx) {
+            const p = (input ?? {});
+            const sheetId = await resolveSheetId(ctx, p.spreadsheetId, p.sheet);
+            const grid = a1RangeToGridRange(p.range, sheetId);
+            return spreadsheetBatchUpdate(ctx, p.spreadsheetId, [
+                { addNamedRange: { namedRange: { name: p.name, range: grid } } },
+            ]);
+        },
+    });
+    rl.registerAction("namedRange.delete", {
+        description: "Delete a named range by its id.",
+        inputSchema: {
+            spreadsheetId: { type: "string", required: true },
+            namedRangeId: { type: "string", required: true },
+        },
+        async execute(input, ctx) {
+            const p = (input ?? {});
+            return spreadsheetBatchUpdate(ctx, p.spreadsheetId, [
+                { deleteNamedRange: { namedRangeId: p.namedRangeId } },
+            ]);
+        },
+    });
+    // ─── Protected ranges ───────────────────────────────────────────
+    rl.registerAction("protectedRange.add", {
+        description: "Protect a range from edits. Pass `editorEmails` to restrict who can still edit; without it, only the sheet owner can edit.",
+        inputSchema: {
+            spreadsheetId: { type: "string", required: true },
+            sheet: { type: "string", required: true },
+            range: { type: "string", required: false, description: "A1 range. Omit to protect the whole sheet." },
+            description: { type: "string", required: false },
+            warningOnly: { type: "boolean", required: false, description: "When true, edits are allowed but show a warning." },
+            editorEmails: { type: "array", required: false },
+        },
+        async execute(input, ctx) {
+            const p = (input ?? {});
+            const sheetId = await resolveSheetId(ctx, p.spreadsheetId, p.sheet);
+            const protectedRange = { description: p.description, warningOnly: p.warningOnly };
+            if (p.range)
+                protectedRange.range = a1RangeToGridRange(p.range, sheetId);
+            else
+                protectedRange.range = { sheetId };
+            if (Array.isArray(p.editorEmails)) {
+                protectedRange.editors = { users: p.editorEmails };
+            }
+            return spreadsheetBatchUpdate(ctx, p.spreadsheetId, [
+                { addProtectedRange: { protectedRange } },
+            ]);
+        },
+    });
+    rl.registerAction("protectedRange.delete", {
+        description: "Delete a protected range by its id.",
+        inputSchema: {
+            spreadsheetId: { type: "string", required: true },
+            protectedRangeId: { type: "number", required: true },
+        },
+        async execute(input, ctx) {
+            const p = (input ?? {});
+            return spreadsheetBatchUpdate(ctx, p.spreadsheetId, [
+                { deleteProtectedRange: { protectedRangeId: p.protectedRangeId } },
+            ]);
+        },
+    });
+    // ─── Conditional formatting ─────────────────────────────────────
+    rl.registerAction("conditionalFormat.add", {
+        description: "Add a single-condition conditional-format rule. For complex rules pass a raw `rule` object instead of the simple builder.",
+        inputSchema: {
+            spreadsheetId: { type: "string", required: true },
+            sheet: { type: "string", required: true },
+            range: { type: "string", required: true },
+            condition: {
+                type: "object",
+                required: false,
+                description: "BooleanCondition, e.g. { type: 'NUMBER_GREATER', values: [{ userEnteredValue: '100' }] }.",
+            },
+            backgroundColorHex: { type: "string", required: false },
+            foregroundColorHex: { type: "string", required: false },
+            bold: { type: "boolean", required: false },
+            italic: { type: "boolean", required: false },
+            rule: { type: "object", required: false, description: "Raw ConditionalFormatRule; bypasses the simple builder." },
+        },
+        async execute(input, ctx) {
+            const p = (input ?? {});
+            const sheetId = await resolveSheetId(ctx, p.spreadsheetId, p.sheet);
+            const grid = a1RangeToGridRange(p.range, sheetId);
+            let rule;
+            if (p.rule)
+                rule = p.rule;
+            else {
+                const fmt = {};
+                if (p.backgroundColorHex)
+                    fmt.backgroundColor = hexToRgb(p.backgroundColorHex);
+                if (p.foregroundColorHex || p.bold || p.italic) {
+                    const ts = {};
+                    if (p.foregroundColorHex)
+                        ts.foregroundColor = hexToRgb(p.foregroundColorHex);
+                    if (p.bold !== undefined)
+                        ts.bold = p.bold;
+                    if (p.italic !== undefined)
+                        ts.italic = p.italic;
+                    fmt.textFormat = ts;
+                }
+                rule = { ranges: [grid], booleanRule: { condition: p.condition, format: fmt } };
+            }
+            return spreadsheetBatchUpdate(ctx, p.spreadsheetId, [{ addConditionalFormatRule: { rule, index: 0 } }]);
+        },
+    });
+    rl.registerAction("conditionalFormat.delete", {
+        description: "Delete a conditional-format rule by its index within the sheet's rule list.",
+        inputSchema: {
+            spreadsheetId: { type: "string", required: true },
+            sheet: { type: "string", required: true },
+            index: { type: "number", required: true },
+        },
+        async execute(input, ctx) {
+            const p = (input ?? {});
+            const sheetId = await resolveSheetId(ctx, p.spreadsheetId, p.sheet);
+            return spreadsheetBatchUpdate(ctx, p.spreadsheetId, [
+                { deleteConditionalFormatRule: { sheetId, index: p.index } },
+            ]);
+        },
+    });
+    // ─── Data validation ────────────────────────────────────────────
+    rl.registerAction("dataValidation.set", {
+        description: "Apply a data-validation rule to a range. Pass either `condition` (BooleanCondition) or `oneOfList` (array of values for ONE_OF_LIST). Use `clear: true` to remove validation.",
+        inputSchema: {
+            spreadsheetId: { type: "string", required: true },
+            sheet: { type: "string", required: true },
+            range: { type: "string", required: true },
+            condition: { type: "object", required: false },
+            oneOfList: { type: "array", required: false },
+            showCustomUi: { type: "boolean", required: false, default: true },
+            strict: { type: "boolean", required: false, default: true },
+            inputMessage: { type: "string", required: false },
+            clear: { type: "boolean", required: false },
+        },
+        async execute(input, ctx) {
+            const p = (input ?? {});
+            const sheetId = await resolveSheetId(ctx, p.spreadsheetId, p.sheet);
+            const grid = a1RangeToGridRange(p.range, sheetId);
+            let rule = null;
+            if (!p.clear) {
+                let cond = p.condition;
+                if (!cond && Array.isArray(p.oneOfList)) {
+                    cond = {
+                        type: "ONE_OF_LIST",
+                        values: p.oneOfList.map((v) => ({ userEnteredValue: String(v) })),
+                    };
+                }
+                if (!cond)
+                    throw new Error("googleSheets.dataValidation.set: pass condition or oneOfList, or set clear=true");
+                rule = { condition: cond, strict: p.strict ?? true, showCustomUi: p.showCustomUi ?? true, inputMessage: p.inputMessage };
+            }
+            return spreadsheetBatchUpdate(ctx, p.spreadsheetId, [
+                { setDataValidation: { range: grid, rule: rule ?? undefined } },
+            ]);
+        },
+    });
 }

package/dist/plugins/microsoftCalendar/src/index.js

@@ -0,0 +1,46 @@
+import { graphRequest, microsoftSetupHelp, userBase } from "../../_shared/microsoftAuth.js";
+const NAME = "microsoftCalendar";
+const SCOPES = ["https://graph.microsoft.com/Calendars.Read"];
+export default function microsoftCalendar(rl) {
+    rl.setName(NAME);
+    rl.setVersion("1.0.0");
+    rl.setConnectionSchema({
+        tenantId: { type: "string", required: false, env: "MS_GRAPH_TENANT_ID", description: "Entra tenant id (app-only) or omit for OAuth /common" },
+        clientId: { type: "string", required: false, env: "MS_GRAPH_CLIENT_ID", description: "App (client) id" },
+        clientSecret: { type: "string", required: false, env: "MS_GRAPH_CLIENT_SECRET", description: "Client secret VALUE" },
+        refreshToken: { type: "string", required: false, env: "MICROSOFTCALENDAR_REFRESH_TOKEN", description: "OAuth2 refresh token (set by the login flow)" },
+        userUpn: { type: "string", required: false, env: "MS_GRAPH_USER_UPN", description: "App-only only: target user UPN" },
+    });
+    rl.setOAuth({
+        authUrl: "https://login.microsoftonline.com/common/oauth2/v2.0/authorize",
+        tokenUrl: "https://login.microsoftonline.com/common/oauth2/v2.0/token",
+        scopes: [...SCOPES, "offline_access"],
+        setupHelp: microsoftSetupHelp("Calendars.Read"),
+    });
+    rl.registerAction("calendar.list", {
+        description: "List calendar events in a date range. Returns [{id,subject,start,end,location,organizer,attendees}].",
+        inputSchema: {
+            start: { type: "string", required: true, description: "ISO start datetime, e.g. 2026-05-01T00:00:00Z" },
+            end: { type: "string", required: true, description: "ISO end datetime" },
+            top: { type: "number", required: false, default: 50 },
+        },
+        async execute(input, ctx) {
+            const qs = new URLSearchParams({
+                startDateTime: input.start,
+                endDateTime: input.end,
+                $top: String(input.top ?? 50),
+                $select: "id,subject,start,end,location,organizer,attendees,isAllDay,webLink",
+                $orderby: "start/dateTime",
+            });
+            const r = await graphRequest(ctx, NAME, SCOPES, "GET", `${userBase(ctx)}/calendarView?${qs}`);
+            return r.value;
+        },
+    });
+    rl.registerAction("event.get", {
+        description: "Get one calendar event by id (full details incl. body).",
+        inputSchema: { id: { type: "string", required: true } },
+        async execute(input, ctx) {
+            return graphRequest(ctx, NAME, SCOPES, "GET", `${userBase(ctx)}/events/${input.id}`);
+        },
+    });
+}

package/dist/plugins/microsoftFiles/src/index.js

@@ -0,0 +1,127 @@
+import { graphRequest, microsoftAccessToken, microsoftSetupHelp, userBase, } from "../../_shared/microsoftAuth.js";
+const NAME = "microsoftFiles";
+const SCOPES = [
+    "https://graph.microsoft.com/Files.ReadWrite.All",
+    "https://graph.microsoft.com/Sites.ReadWrite.All",
+];
+/** Resolve the drive root path: explicit drive/site, else the user's default drive. */
+function driveBase(ctx) {
+    const cfg = ctx.connection.config;
+    if (cfg.driveId)
+        return `/drives/${cfg.driveId}`;
+    if (cfg.siteId)
+        return `/sites/${cfg.siteId}/drive`;
+    return `${userBase(ctx)}/drive`;
+}
+async function binaryFetch(ctx, method, path, body) {
+    const token = await microsoftAccessToken(ctx, NAME, SCOPES);
+    const init = {
+        method,
+        headers: {
+            Authorization: `Bearer ${token}`,
+            ...(body ? { "Content-Type": "application/octet-stream" } : {}),
+        },
+    };
+    if (body)
+        init.body = body;
+    return fetch(`https://graph.microsoft.com/v1.0${path}`, init);
+}
+export default function microsoftFiles(rl) {
+    rl.setName(NAME);
+    rl.setVersion("1.0.0");
+    rl.setConnectionSchema({
+        tenantId: { type: "string", required: false, env: "MS_GRAPH_TENANT_ID", description: "Entra tenant id (app-only) or omit for OAuth /common" },
+        clientId: { type: "string", required: false, env: "MS_GRAPH_CLIENT_ID", description: "App (client) id" },
+        clientSecret: { type: "string", required: false, env: "MS_GRAPH_CLIENT_SECRET", description: "Client secret VALUE" },
+        refreshToken: { type: "string", required: false, env: "MICROSOFTFILES_REFRESH_TOKEN", description: "OAuth2 refresh token (set by the login flow)" },
+        userUpn: { type: "string", required: false, env: "MS_GRAPH_USER_UPN", description: "App-only only: target user UPN (their OneDrive)" },
+        siteId: { type: "string", required: false, env: "MS_SHAREPOINT_SITE_ID", description: "Optional SharePoint site id (use its default drive)" },
+        driveId: { type: "string", required: false, env: "MS_GRAPH_DRIVE_ID", description: "Optional explicit drive id (overrides site/user)" },
+    });
+    rl.setOAuth({
+        authUrl: "https://login.microsoftonline.com/common/oauth2/v2.0/authorize",
+        tokenUrl: "https://login.microsoftonline.com/common/oauth2/v2.0/token",
+        scopes: [...SCOPES, "offline_access"],
+        setupHelp: microsoftSetupHelp("Files.ReadWrite.All, Sites.ReadWrite.All"),
+    });
+    rl.registerAction("files.search", {
+        description: "Search the drive for files/folders by text. Returns [{id,name,size,lastModifiedDateTime,webUrl,folder?}].",
+        inputSchema: {
+            query: { type: "string", required: true },
+            top: { type: "number", required: false, default: 25 },
+        },
+        async execute(input, ctx) {
+            const q = encodeURIComponent(String(input.query).replace(/'/g, "''"));
+            const qs = new URLSearchParams({
+                $top: String(input.top ?? 25),
+                $select: "id,name,size,lastModifiedDateTime,webUrl,folder,file",
+            });
+            const r = await graphRequest(ctx, NAME, SCOPES, "GET", `${driveBase(ctx)}/root/search(q='${q}')?${qs}`);
+            return r.value;
+        },
+    });
+    rl.registerAction("files.list", {
+        description: "List children of a folder (default the drive root, or pass folderId).",
+        inputSchema: {
+            folderId: { type: "string", required: false, description: "Folder item id; omit for root" },
+            top: { type: "number", required: false, default: 100 },
+        },
+        async execute(input, ctx) {
+            const where = input.folderId ? `/items/${input.folderId}/children` : "/root/children";
+            const qs = new URLSearchParams({
+                $top: String(input.top ?? 100),
+                $select: "id,name,size,lastModifiedDateTime,webUrl,folder,file",
+            });
+            const r = await graphRequest(ctx, NAME, SCOPES, "GET", `${driveBase(ctx)}${where}?${qs}`);
+            return r.value;
+        },
+    });
+    rl.registerAction("files.get", {
+        description: "Download a file by id. Returns {id,name,size,contentType,base64}. base64 is the file bytes.",
+        inputSchema: { id: { type: "string", required: true } },
+        async execute(input, ctx) {
+            const meta = await graphRequest(ctx, NAME, SCOPES, "GET", `${driveBase(ctx)}/items/${input.id}`);
+            const res = await binaryFetch(ctx, "GET", `${driveBase(ctx)}/items/${input.id}/content`);
+            if (!res.ok)
+                throw new Error(`${NAME}: download ${input.id} → ${res.status} ${await res.text()}`);
+            const buf = Buffer.from(await res.arrayBuffer());
+            return {
+                id: meta.id,
+                name: meta.name,
+                size: meta.size,
+                contentType: meta.file?.mimeType,
+                base64: buf.toString("base64"),
+            };
+        },
+    });
+    rl.registerAction("files.upload", {
+        description: "Upload a file (base64) to a path in the drive, e.g. a dedicated output folder. Returns the created item. For files up to ~4MB.",
+        inputSchema: {
+            path: { type: "string", required: true, description: "Drive-relative path incl. filename, e.g. 'Agent Output/report.docx'" },
+            base64: { type: "string", required: true, description: "File content, base64-encoded" },
+        },
+        async execute(input, ctx) {
+            const bytes = Buffer.from(input.base64, "base64");
+            const p = input.path.split("/").map(encodeURIComponent).join("/");
+            const res = await binaryFetch(ctx, "PUT", `${driveBase(ctx)}/root:/${p}:/content`, bytes);
+            if (!res.ok)
+                throw new Error(`${NAME}: upload ${input.path} → ${res.status} ${await res.text()}`);
+            return JSON.parse(await res.text());
+        },
+    });
+    rl.registerAction("folder.create", {
+        description: "Create a folder (e.g. a dedicated agent output folder) under the drive root or a parent.",
+        inputSchema: {
+            name: { type: "string", required: true },
+            parentId: { type: "string", required: false, description: "Parent folder id; omit for root" },
+        },
+        async execute(input, ctx) {
+            const where = input.parentId ? `/items/${input.parentId}/children` : "/root/children";
+            return graphRequest(ctx, NAME, SCOPES, "POST", `${driveBase(ctx)}${where}`, {
+                name: input.name,
+                folder: {},
+                "@microsoft.graph.conflictBehavior": "rename",
+            });
+        },
+    });
+}

package/dist/plugins/microsoftMail/src/index.js

@@ -0,0 +1,91 @@
+import { graphRequest, microsoftSetupHelp, userBase } from "../../_shared/microsoftAuth.js";
+const NAME = "microsoftMail";
+const SCOPES = [
+    "https://graph.microsoft.com/Mail.Send",
+    "https://graph.microsoft.com/Mail.ReadWrite",
+    "https://graph.microsoft.com/Mail.Read",
+];
+const recipients = (addrs) => (Array.isArray(addrs) ? addrs : addrs ? [addrs] : []).map((a) => ({
+    emailAddress: { address: a },
+}));
+function toMessage(input) {
+    return {
+        subject: input.subject,
+        body: { contentType: input.html ? "HTML" : "Text", content: input.body ?? "" },
+        toRecipients: recipients(input.to),
+        ccRecipients: recipients(input.cc),
+    };
+}
+export default function microsoftMail(rl) {
+    rl.setName(NAME);
+    rl.setVersion("1.0.0");
+    rl.setConnectionSchema({
+        tenantId: { type: "string", required: false, env: "MS_GRAPH_TENANT_ID", description: "Entra tenant id (app-only) or omit for OAuth /common" },
+        clientId: { type: "string", required: false, env: "MS_GRAPH_CLIENT_ID", description: "App (client) id" },
+        clientSecret: { type: "string", required: false, env: "MS_GRAPH_CLIENT_SECRET", description: "Client secret VALUE" },
+        refreshToken: { type: "string", required: false, env: "MICROSOFTMAIL_REFRESH_TOKEN", description: "OAuth2 refresh token (set by the login flow)" },
+        userUpn: { type: "string", required: false, env: "MS_GRAPH_USER_UPN", description: "App-only only: target mailbox UPN (e.g. agent@contoso.com)" },
+    });
+    rl.setOAuth({
+        authUrl: "https://login.microsoftonline.com/common/oauth2/v2.0/authorize",
+        tokenUrl: "https://login.microsoftonline.com/common/oauth2/v2.0/token",
+        scopes: [...SCOPES, "offline_access"],
+        setupHelp: microsoftSetupHelp("Mail.Send, Mail.ReadWrite, Mail.Read"),
+    });
+    rl.registerAction("mail.send", {
+        description: "Send an email as the connected mailbox. Returns {success}. Get user approval before sending external mail.",
+        inputSchema: {
+            to: { type: "array", required: true, description: "Recipient address(es)" },
+            subject: { type: "string", required: true },
+            body: { type: "string", required: true },
+            cc: { type: "array", required: false },
+            html: { type: "boolean", required: false, description: "Body is HTML (default plain text)" },
+        },
+        async execute(input, ctx) {
+            await graphRequest(ctx, NAME, SCOPES, "POST", `${userBase(ctx)}/sendMail`, {
+                message: toMessage(input),
+                saveToSentItems: true,
+            });
+            return { success: true };
+        },
+    });
+    rl.registerAction("mail.draft", {
+        description: "Create a draft email (not sent). Returns {id, webLink}.",
+        inputSchema: {
+            to: { type: "array", required: false },
+            subject: { type: "string", required: true },
+            body: { type: "string", required: true },
+            cc: { type: "array", required: false },
+            html: { type: "boolean", required: false },
+        },
+        async execute(input, ctx) {
+            const r = await graphRequest(ctx, NAME, SCOPES, "POST", `${userBase(ctx)}/messages`, toMessage(input));
+            return { id: r.id, webLink: r.webLink };
+        },
+    });
+    rl.registerAction("mail.list", {
+        description: "List recent messages. Optional KQL search. Returns [{id,subject,from,receivedDateTime,bodyPreview,hasAttachments}].",
+        inputSchema: {
+            search: { type: "string", required: false, description: "KQL search across the mailbox" },
+            top: { type: "number", required: false, default: 20 },
+        },
+        async execute(input, ctx) {
+            const qs = new URLSearchParams({
+                $top: String(input.top ?? 20),
+                $select: "id,subject,from,receivedDateTime,bodyPreview,hasAttachments",
+                $orderby: "receivedDateTime desc",
+            });
+            if (input.search)
+                qs.set("$search", `"${input.search}"`);
+            const r = await graphRequest(ctx, NAME, SCOPES, "GET", `${userBase(ctx)}/messages?${qs}`);
+            return r.value;
+        },
+    });
+    rl.registerAction("mail.get", {
+        description: "Get one message with full body by id.",
+        inputSchema: { id: { type: "string", required: true } },
+        async execute(input, ctx) {
+            return graphRequest(ctx, NAME, SCOPES, "GET", `${userBase(ctx)}/messages/${input.id}`);
+        },
+    });
+}