runline 0.7.7 → 0.8.1

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}`);
+        },
+    });
+}

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

@@ -1,23 +1,22 @@
 /**
  * OpenAI image generation for runline.
  *
- * Wraps the GPT Image / DALL-E line at /v1/images/generations and
- * returns base64 bytes alongside the (optional) revised prompt the
- * model wrote for itself.
+ * Wraps the GPT Image / DALL-E line at /v1/images/generations. Generated
+ * images are written to disk and the action returns their file `path`s
+ * (plus the optional revised prompt) — 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.
  *
  * Quality leader for text rendering and prompt adherence — pair with
  * any other plugin you'd compose images for (storyblok, github,
  * notion, slack uploads, …).
  *
- *   await openai.image.create({ prompt: "a red bicycle on snow" })
- *   await openai.image.create({
- *     prompt: "logo for a coffee shop",
- *     model: "dall-e-3",
- *     style: "vivid",
- *     quality: "high",
- *     size: "1024x1024",
- *   })
+ *   const { images } = await openai.image.create({ prompt: "a red bicycle on snow" })
+ *   // images[0].path -> "/tmp/openai-image-….png"
  */
+import { writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
 const ENDPOINT = "https://api.openai.com/v1/images/generations";
 export default function openai(rl) {
     rl.setName("openai");
@@ -29,19 +28,30 @@ export default function openai(rl) {
             description: "OpenAI API key",
             env: "OPENAI_API_KEY",
         },
+        defaultModel: {
+            type: "string",
+            required: false,
+            description: "Default image model when a call omits `model` (e.g. gpt-image-2). Falls back to gpt-image-1.",
+            env: "OPENAI_IMAGE_MODEL",
+        },
     });
     rl.registerAction("image.create", {
-        description: "Generate an image with OpenAI (GPT Image / DALL-E). Returns base64-encoded PNGs and any revised prompt the model produced.",
+        description: "Generate an image with OpenAI (GPT Image / DALL-E). Writes the PNG(s) to disk and returns their file `path`s (plus any revised prompt) — not base64. Deliver each image to the user with send_file using its `path`.",
         inputSchema: {
             prompt: {
                 type: "string",
                 required: true,
                 description: "Detailed description of the image",
             },
+            saveDir: {
+                type: "string",
+                required: false,
+                description: "Directory to write the image file(s) into. Defaults to the OS temp dir.",
+            },
             model: {
                 type: "string",
                 required: false,
-                description: "gpt-image-1 (default) | gpt-image-1-mini | dall-e-3 | dall-e-2",
+                description: "gpt-image-2 | gpt-image-1 | gpt-image-1-mini | dall-e-3 | dall-e-2. Omit to use the connection default.",
             },
             size: {
                 type: "string",
@@ -70,7 +80,9 @@ export default function openai(rl) {
                 throw new Error("openai: prompt is required");
             }
             const apiKey = ctx.connection.config.apiKey;
-            const model = p.model ?? "gpt-image-1";
+            const model = p.model ??
+                ctx.connection.config.defaultModel ??
+                "gpt-image-1";
             const body = {
                 model,
                 prompt: p.prompt,
@@ -101,12 +113,25 @@ export default function openai(rl) {
                 throw new Error(`OpenAI API error ${res.status}: ${await res.text()}`);
             }
             const data = (await res.json());
-            const images = (data.data ?? []).map((d) => ({
-                base64: d.b64_json,
-                mimeType: "image/png",
-                ...(d.revised_prompt ? { revisedPrompt: d.revised_prompt } : {}),
-            }));
-            return { provider: "openai", model, images };
+            const dir = (typeof p.saveDir === "string" && p.saveDir.trim()) || tmpdir();
+            const stamp = Date.now();
+            const images = (data.data ?? []).map((d, i) => {
+                const bytes = Buffer.from(d.b64_json ?? "", "base64");
+                const path = join(dir, `openai-image-${stamp}-${i}.png`);
+                writeFileSync(path, bytes);
+                return {
+                    path,
+                    mimeType: "image/png",
+                    byteLength: bytes.length,
+                    ...(d.revised_prompt ? { revisedPrompt: d.revised_prompt } : {}),
+                };
+            });
+            return {
+                provider: "openai",
+                model,
+                images,
+                note: "Image(s) written to disk. Deliver each to the user with send_file using its `path`.",
+            };
         },
     });
 }

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

@@ -0,0 +1,100 @@
+const NAME = "parallel";
+const DEFAULT_BASE = "https://api.parallel.ai";
+export default function parallel(rl) {
+    rl.setName(NAME);
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        apiKey: {
+            type: "string",
+            required: true,
+            env: "PARALLEL_API_KEY",
+            description: "Parallel.ai API key (sent as the x-api-key header). Store only in secrets.",
+        },
+        baseUrl: {
+            type: "string",
+            required: false,
+            env: "PARALLEL_API_BASE",
+            default: DEFAULT_BASE,
+            description: "Parallel.ai API base URL.",
+        },
+    });
+    rl.registerAction("search", {
+        description: "Search the live web with Parallel.ai and get ranked results with extracted excerpts. Use this to ground answers in current web content (news, prices, regulations, company info) instead of stale knowledge. Provide an `objective` (natural-language goal) and/or explicit `search_queries`.",
+        inputSchema: {
+            objective: {
+                type: "string",
+                required: false,
+                description: "Natural-language description of what you're trying to find. Recommended; can be used with or instead of search_queries.",
+            },
+            search_queries: {
+                type: "array",
+                required: false,
+                description: "Optional explicit query strings to run (e.g. [\"x vacancy rate 2026\"]). Provide objective and/or this.",
+            },
+            processor: {
+                type: "string",
+                required: false,
+                default: "base",
+                description: "base (fast, default) or pro (deeper, slower/costlier).",
+            },
+            max_results: {
+                type: "number",
+                required: false,
+                default: 5,
+                description: "Max results to return (default 5).",
+            },
+            max_chars_per_result: {
+                type: "number",
+                required: false,
+                description: "Optional cap on extracted characters per result.",
+            },
+        },
+        async execute(input, ctx) {
+            const cfg = (ctx.connection.config ?? {});
+            const apiKey = cfg.apiKey;
+            if (!apiKey)
+                throw new Error("Missing PARALLEL_API_KEY. Configure it before using the parallel plugin.");
+            const baseUrl = (cfg.baseUrl || DEFAULT_BASE).replace(/\/+$/, "");
+            const objective = typeof input.objective === "string" ? input.objective.trim() : "";
+            const queries = Array.isArray(input.search_queries)
+                ? input.search_queries.map((q) => String(q)).filter((q) => q.trim())
+                : [];
+            if (!objective && !queries.length) {
+                throw new Error("Provide objective and/or search_queries");
+            }
+            const body = {
+                processor: String(input.processor || "base"),
+                max_results: Number(input.max_results) > 0 ? Math.floor(Number(input.max_results)) : 5,
+            };
+            if (objective)
+                body.objective = objective;
+            if (queries.length)
+                body.search_queries = queries;
+            if (Number(input.max_chars_per_result) > 0) {
+                body.max_chars_per_result = Math.floor(Number(input.max_chars_per_result));
+            }
+            const res = await fetch(`${baseUrl}/v1beta/search`, {
+                method: "POST",
+                headers: { "x-api-key": apiKey, "Content-Type": "application/json" },
+                body: JSON.stringify(body),
+            });
+            const text = await res.text();
+            if (!res.ok) {
+                throw new Error(`Parallel search -> ${res.status}: ${text.slice(0, 300)}`);
+            }
+            const data = text ? JSON.parse(text) : {};
+            const results = (data.results ?? []).map((r) => ({
+                url: r.url,
+                title: r.title,
+                excerpts: r.excerpts ?? [],
+            }));
+            return {
+                searchId: data.search_id,
+                count: results.length,
+                results,
+                warnings: data.warnings ?? undefined,
+                source: "parallel.search",
+            };
+        },
+    });
+}

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

@@ -13,6 +13,7 @@
  * legacy `style` knob — pass `styleId` against your own custom
  * style if you've set one up.
  */
+import { SEND_FILE_NOTE, writeImageFile } from "../../_shared/imageFile.js";
 const ENDPOINT = "https://external.api.recraft.ai/v1/images/generations";
 export default function recraft(rl) {
     rl.setName("recraft");
@@ -26,13 +27,18 @@ export default function recraft(rl) {
         },
     });
     rl.registerAction("image.create", {
-        description: "Generate an image with Recraft. Best for design, vector graphics, and brand-consistent work. Returns base64-encoded PNGs.",
+        description: "Generate an image with Recraft. Best for design, vector graphics, and brand-consistent work. Writes the image(s) to disk and returns their file `path`s — not base64. Deliver each with send_file using its `path`.",
         inputSchema: {
             prompt: {
                 type: "string",
                 required: true,
                 description: "Detailed description of the image",
             },
+            saveDir: {
+                type: "string",
+                required: false,
+                description: "Directory to write the image file(s) into. Defaults to the OS temp dir.",
+            },
             model: {
                 type: "string",
                 required: false,
@@ -90,11 +96,9 @@ export default function recraft(rl) {
                 throw new Error(`Recraft API error ${res.status}: ${await res.text()}`);
             }
             const data = (await res.json());
-            const images = (data.data ?? []).map((d) => ({
-                base64: d.b64_json,
-                mimeType: "image/png",
-            }));
-            return { provider: "recraft", model, images };
+            const stamp = Date.now();
+            const images = (data.data ?? []).map((d, i) => writeImageFile({ base64: d.b64_json, mimeType: "image/png", provider: "recraft", index: i, saveDir: p.saveDir, stamp }));
+            return { provider: "recraft", model, images, note: SEND_FILE_NOTE };
         },
     });
 }

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

@@ -19,6 +19,7 @@
  * separately.
  */
 import { Buffer } from "node:buffer";
+import { SEND_FILE_NOTE, writeImageFile } from "../../_shared/imageFile.js";
 import { parseSize } from "../../_shared/parseSize.js";
 const POLL_INTERVAL_MS = 2_000;
 const DEFAULT_TIMEOUT_MS = 5 * 60 * 1000;
@@ -46,13 +47,18 @@ export default function replicate(rl) {
         },
     });
     rl.registerAction("image.create", {
-        description: "Generate an image via Replicate. Default model is black-forest-labs/flux-dev. Returns base64 bytes from the model's output URLs.",
+        description: "Generate an image via Replicate. Default model is black-forest-labs/flux-dev. Writes the image(s) to disk and returns their file `path`s — not base64. Deliver each with send_file using its `path`.",
         inputSchema: {
             prompt: {
                 type: "string",
                 required: true,
                 description: "Detailed description of the image",
             },
+            saveDir: {
+                type: "string",
+                required: false,
+                description: "Directory to write the image file(s) into. Defaults to the OS temp dir.",
+            },
             model: {
                 type: "string",
                 required: false,
@@ -136,6 +142,7 @@ export default function replicate(rl) {
                     : [];
             const images = [];
             const failures = [];
+            const stamp = Date.now();
             for (const url of outputs) {
                 if (typeof url !== "string") {
                     failures.push({ url: String(url), reason: "non-string output" });
@@ -153,13 +160,20 @@ export default function replicate(rl) {
                 const contentType = (imgRes.headers.get("content-type") ?? "image/webp")
                     .split(";")[0]
                     .trim();
-                images.push({ base64: buf.toString("base64"), mimeType: contentType });
+                images.push(writeImageFile({
+                    base64: buf.toString("base64"),
+                    mimeType: contentType,
+                    provider: "replicate",
+                    index: images.length,
+                    saveDir: p.saveDir,
+                    stamp,
+                }));
             }
             if (images.length === 0 && outputs.length > 0) {
                 const detail = failures.map((f) => `${f.url}: ${f.reason}`).join("; ");
                 throw new Error(`Replicate succeeded but all ${outputs.length} output URLs failed to download — ${detail}`);
             }
-            const result = { provider: "replicate", model, images };
+            const result = { provider: "replicate", model, images, note: SEND_FILE_NOTE };
             if (failures.length > 0)
                 result.failures = failures;
             return result;