runline 0.6.0 → 0.7.0

package/dist/plugins/_shared/parseSize.js

@@ -0,0 +1,26 @@
+/**
+ * Parse a `WxH` string into a { width, height } pair.
+ *
+ * Used by image-gen plugins (replicate, together, …) that take a
+ * single `size` input but talk to APIs which want explicit
+ * dimensions. Throws with the caller's plugin name in the message
+ * so error output points back at the right tool.
+ *
+ *   parseSize("1024x1024", "replicate")  // { width: 1024, height: 1024 }
+ *   parseSize(undefined, "replicate")    // defaults to 1024x1024
+ *   parseSize("1024", "replicate")       // throws
+ */
+export function parseSize(size, pluginName, defaults = { width: 1024, height: 1024 }) {
+    if (!size)
+        return { ...defaults };
+    const parts = size.split("x").map((s) => Number(s.trim()));
+    if (parts.length !== 2 ||
+        !Number.isFinite(parts[0]) ||
+        !Number.isFinite(parts[1])) {
+        throw new Error(`${pluginName}: invalid size "${size}", expected WxH`);
+    }
+    if (parts[0] <= 0 || parts[1] <= 0) {
+        throw new Error(`${pluginName}: size dimensions must be positive`);
+    }
+    return { width: parts[0], height: parts[1] };
+}

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

@@ -0,0 +1,79 @@
+/**
+ * Google Gemini image generation (Nano Banana / Imagen) for runline.
+ *
+ * Distinct from the rest of the googleX family — those wrap Workspace
+ * APIs over OAuth2, this one wraps Generative Language over a single
+ * 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",
+ *   })
+ *
+ * Nano Banana supports conversational editing — chain prompts in
+ * follow-up calls and it'll keep iterating on the last image.
+ */
+const BASE = "https://generativelanguage.googleapis.com/v1beta/models";
+export default function googleImage(rl) {
+    rl.setName("googleImage");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        apiKey: {
+            type: "string",
+            required: true,
+            description: "Google AI API key (Gemini)",
+            env: "GOOGLE_API_KEY",
+        },
+    });
+    rl.registerAction("image.create", {
+        description: "Generate an image with Google's Gemini image models (Nano Banana / Imagen). Returns base64 bytes per candidate.",
+        inputSchema: {
+            prompt: {
+                type: "string",
+                required: true,
+                description: "Detailed description of the image",
+            },
+            model: {
+                type: "string",
+                required: false,
+                description: "gemini-2.5-flash-image (Nano Banana, default) | gemini-3-pro-image-preview | gemini-3.1-flash-image-preview",
+            },
+        },
+        async execute(input, ctx) {
+            const p = (input ?? {});
+            if (typeof p.prompt !== "string" || p.prompt.length === 0) {
+                throw new Error("googleImage: prompt is required");
+            }
+            const apiKey = ctx.connection.config.apiKey;
+            const model = p.model ?? "gemini-2.5-flash-image";
+            const url = `${BASE}/${model}:generateContent?key=${encodeURIComponent(apiKey)}`;
+            const body = {
+                contents: [{ parts: [{ text: p.prompt }] }],
+                generationConfig: { responseModalities: ["IMAGE", "TEXT"] },
+            };
+            const res = await fetch(url, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify(body),
+            });
+            if (!res.ok) {
+                throw new Error(`Google API error ${res.status}: ${await res.text()}`);
+            }
+            const data = (await res.json());
+            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",
+                        });
+                    }
+                }
+            }
+            return { provider: "googleImage", model, images };
+        },
+    });
+}

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

@@ -0,0 +1,112 @@
+/**
+ * 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.
+ *
+ * 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 ENDPOINT = "https://api.openai.com/v1/images/generations";
+export default function openai(rl) {
+    rl.setName("openai");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        apiKey: {
+            type: "string",
+            required: true,
+            description: "OpenAI API key",
+            env: "OPENAI_API_KEY",
+        },
+    });
+    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.",
+        inputSchema: {
+            prompt: {
+                type: "string",
+                required: true,
+                description: "Detailed description of the image",
+            },
+            model: {
+                type: "string",
+                required: false,
+                description: "gpt-image-1 (default) | gpt-image-1-mini | dall-e-3 | dall-e-2",
+            },
+            size: {
+                type: "string",
+                required: false,
+                description: "WxH (default: 1024x1024). Allowed sizes vary by model.",
+            },
+            quality: {
+                type: "string",
+                required: false,
+                description: "low | medium | high (gpt-image) or standard | hd (dall-e-3)",
+            },
+            style: {
+                type: "string",
+                required: false,
+                description: "vivid | natural — DALL-E 3 only",
+            },
+            n: {
+                type: "number",
+                required: false,
+                description: "Number of images (default: 1, max: 4)",
+            },
+        },
+        async execute(input, ctx) {
+            const p = (input ?? {});
+            if (typeof p.prompt !== "string" || p.prompt.length === 0) {
+                throw new Error("openai: prompt is required");
+            }
+            const apiKey = ctx.connection.config.apiKey;
+            const model = p.model ?? "gpt-image-1";
+            const body = {
+                model,
+                prompt: p.prompt,
+                n: Math.min(p.n ?? 1, 4),
+                size: p.size ?? "1024x1024",
+            };
+            // gpt-image-* uses output_format; dall-e-* uses response_format.
+            // Sending the wrong key 400s, so the model name decides.
+            if (model.startsWith("dall-e")) {
+                body.response_format = "b64_json";
+            }
+            else {
+                body.output_format = "png";
+            }
+            if (p.quality)
+                body.quality = p.quality;
+            if (p.style)
+                body.style = p.style;
+            const res = await fetch(ENDPOINT, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    Authorization: `Bearer ${apiKey}`,
+                },
+                body: JSON.stringify(body),
+            });
+            if (!res.ok) {
+                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 };
+        },
+    });
+}

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

@@ -0,0 +1,100 @@
+/**
+ * Recraft image generation for runline.
+ *
+ *   await recraft.image.create({ prompt: "minimalist line-art coffee cup" })
+ *   await recraft.image.create({
+ *     prompt: "rocket logo, flat vector",
+ *     model: "recraftv3_vector",   // → SVG
+ *     style: "Vector art",
+ *   })
+ *
+ * Recraft is the design-oriented provider: vector output, brand-
+ * consistent style libraries, typography-aware. V4 models drop the
+ * legacy `style` knob — pass `styleId` against your own custom
+ * style if you've set one up.
+ */
+const ENDPOINT = "https://external.api.recraft.ai/v1/images/generations";
+export default function recraft(rl) {
+    rl.setName("recraft");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        apiKey: {
+            type: "string",
+            required: true,
+            description: "Recraft API key",
+            env: "RECRAFT_API_KEY",
+        },
+    });
+    rl.registerAction("image.create", {
+        description: "Generate an image with Recraft. Best for design, vector graphics, and brand-consistent work. Returns base64-encoded PNGs.",
+        inputSchema: {
+            prompt: {
+                type: "string",
+                required: true,
+                description: "Detailed description of the image",
+            },
+            model: {
+                type: "string",
+                required: false,
+                description: "recraftv3 (default) | recraftv3_vector | recraftv4 | recraftv4_pro | recraftv4_vector | recraftv4_pro_vector",
+            },
+            style: {
+                type: "string",
+                required: false,
+                description: "V2/V3 only — Photorealism | Illustration | Vector art | Hand-drawn | Icon | Recraft V3 Raw",
+            },
+            styleId: {
+                type: "string",
+                required: false,
+                description: "ID of a custom style created in your Recraft account",
+            },
+            size: {
+                type: "string",
+                required: false,
+                description: "WxH (default: 1024x1024). E.g. 1280x1024, 1024x1280",
+            },
+            n: {
+                type: "number",
+                required: false,
+                description: "Number of images (default: 1, max: 6)",
+            },
+        },
+        async execute(input, ctx) {
+            const p = (input ?? {});
+            if (typeof p.prompt !== "string" || p.prompt.length === 0) {
+                throw new Error("recraft: prompt is required");
+            }
+            const apiKey = ctx.connection.config.apiKey;
+            const model = p.model ?? "recraftv3";
+            const body = {
+                prompt: p.prompt,
+                model,
+                response_format: "b64_json",
+                n: Math.min(p.n ?? 1, 6),
+            };
+            if (p.size)
+                body.size = p.size;
+            if (p.style)
+                body.style = p.style;
+            if (p.styleId)
+                body.style_id = p.styleId;
+            const res = await fetch(ENDPOINT, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    Authorization: `Bearer ${apiKey}`,
+                },
+                body: JSON.stringify(body),
+            });
+            if (!res.ok) {
+                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 };
+        },
+    });
+}

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

@@ -0,0 +1,168 @@
+/**
+ * Replicate image generation for runline.
+ *
+ *   await replicate.image.create({ prompt: "a samurai under cherry blossoms" })
+ *   await replicate.image.create({
+ *     prompt: "studio portrait, soft lighting",
+ *     model: "stability-ai/stable-diffusion-3.5-large",
+ *     size: "1024x1024",
+ *   })
+ *
+ * Default model is black-forest-labs/flux-dev. Any text-to-image
+ * Replicate model that accepts `prompt` / `width` / `height` /
+ * `num_outputs` works the same way.
+ *
+ * Predictions are created with `Prefer: wait` so simple jobs return
+ * synchronously; anything still processing is polled until terminal
+ * or until `timeoutMs` elapses (default: 5 minutes). Output URLs are
+ * downloaded and base64-encoded so callers don't have to fetch them
+ * separately.
+ */
+import { Buffer } from "node:buffer";
+import { parseSize } from "../../_shared/parseSize.js";
+const POLL_INTERVAL_MS = 2_000;
+const DEFAULT_TIMEOUT_MS = 5 * 60 * 1000;
+function stringifyError(err) {
+    if (err == null)
+        return "unknown error";
+    if (typeof err === "string")
+        return err;
+    try {
+        return JSON.stringify(err);
+    }
+    catch {
+        return String(err);
+    }
+}
+export default function replicate(rl) {
+    rl.setName("replicate");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        apiToken: {
+            type: "string",
+            required: true,
+            description: "Replicate API token",
+            env: "REPLICATE_API_TOKEN",
+        },
+    });
+    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.",
+        inputSchema: {
+            prompt: {
+                type: "string",
+                required: true,
+                description: "Detailed description of the image",
+            },
+            model: {
+                type: "string",
+                required: false,
+                description: "Replicate model id, e.g. black-forest-labs/flux-dev (default), black-forest-labs/flux-schnell, stability-ai/stable-diffusion-3.5-large",
+            },
+            size: {
+                type: "string",
+                required: false,
+                description: "WxH (default: 1024x1024)",
+            },
+            n: {
+                type: "number",
+                required: false,
+                description: "Number of images (default: 1, max: 4)",
+            },
+            timeoutMs: {
+                type: "number",
+                required: false,
+                description: "Max ms to wait for the prediction to finish (default: 300000 = 5 minutes)",
+            },
+        },
+        async execute(input, ctx) {
+            const p = (input ?? {});
+            if (typeof p.prompt !== "string" || p.prompt.length === 0) {
+                throw new Error("replicate: prompt is required");
+            }
+            const apiToken = ctx.connection.config.apiToken;
+            const model = p.model ?? "black-forest-labs/flux-dev";
+            const { width, height } = parseSize(p.size, "replicate");
+            const timeoutMs = p.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+            const deadline = Date.now() + timeoutMs;
+            const createRes = await fetch(`https://api.replicate.com/v1/models/${model}/predictions`, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    Authorization: `Bearer ${apiToken}`,
+                    // `Prefer: wait` lets the server hold the connection open for
+                    // fast jobs so we don't have to poll at all on the happy path.
+                    Prefer: "wait",
+                },
+                body: JSON.stringify({
+                    input: {
+                        prompt: p.prompt,
+                        width,
+                        height,
+                        num_outputs: Math.min(p.n ?? 1, 4),
+                    },
+                }),
+            });
+            if (!createRes.ok) {
+                throw new Error(`Replicate API error ${createRes.status}: ${await createRes.text()}`);
+            }
+            let prediction = (await createRes.json());
+            while (prediction.status !== "succeeded" &&
+                prediction.status !== "failed" &&
+                prediction.status !== "canceled") {
+                if (Date.now() >= deadline) {
+                    throw new Error(`Replicate generation timed out after ${timeoutMs}ms (still ${prediction.status})`);
+                }
+                await new Promise((r) => setTimeout(r, POLL_INTERVAL_MS));
+                const pollRes = await fetch(prediction.urls.get, {
+                    headers: { Authorization: `Bearer ${apiToken}` },
+                });
+                if (!pollRes.ok) {
+                    throw new Error(`Replicate poll error ${pollRes.status}: ${await pollRes.text()}`);
+                }
+                prediction = (await pollRes.json());
+            }
+            if (prediction.status !== "succeeded") {
+                throw new Error(`Replicate generation ${prediction.status}: ${stringifyError(prediction.error)}`);
+            }
+            // Output is either a single URL or an array of them. Download
+            // each and base64-encode so the caller gets bytes back, not
+            // pre-signed URLs that expire. Track per-URL failures and
+            // surface them: silent partial success would let an agent
+            // think it got 3 images when one 404'd.
+            const outputs = Array.isArray(prediction.output)
+                ? prediction.output
+                : prediction.output
+                    ? [prediction.output]
+                    : [];
+            const images = [];
+            const failures = [];
+            for (const url of outputs) {
+                if (typeof url !== "string") {
+                    failures.push({ url: String(url), reason: "non-string output" });
+                    continue;
+                }
+                const imgRes = await fetch(url);
+                if (!imgRes.ok) {
+                    failures.push({
+                        url,
+                        reason: `download failed (${imgRes.status})`,
+                    });
+                    continue;
+                }
+                const buf = Buffer.from(await imgRes.arrayBuffer());
+                const contentType = (imgRes.headers.get("content-type") ?? "image/webp")
+                    .split(";")[0]
+                    .trim();
+                images.push({ base64: buf.toString("base64"), mimeType: contentType });
+            }
+            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 };
+            if (failures.length > 0)
+                result.failures = failures;
+            return result;
+        },
+    });
+}

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

@@ -0,0 +1,93 @@
+/**
+ * Together AI image generation for runline.
+ *
+ *   await together.image.create({ prompt: "a cyberpunk skyline at dusk" })
+ *   await together.image.create({
+ *     prompt: "studio product shot, white background",
+ *     model: "black-forest-labs/FLUX.1-dev",
+ *     steps: 28,
+ *   })
+ *
+ * Default model is FLUX.1-schnell — fastest, 4 steps. For better
+ * fidelity switch to FLUX.1-dev / Ideogram / Qwen-Image and bump
+ * `steps` accordingly (20–30 is typical for non-schnell models).
+ */
+import { parseSize } from "../../_shared/parseSize.js";
+const ENDPOINT = "https://api.together.xyz/v1/images/generations";
+export default function together(rl) {
+    rl.setName("together");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        apiKey: {
+            type: "string",
+            required: true,
+            description: "Together AI API key",
+            env: "TOGETHER_API_KEY",
+        },
+    });
+    rl.registerAction("image.create", {
+        description: "Generate an image with Together AI (Flux, Ideogram, Qwen-Image, …). Returns base64-encoded PNGs.",
+        inputSchema: {
+            prompt: {
+                type: "string",
+                required: true,
+                description: "Detailed description of the image",
+            },
+            model: {
+                type: "string",
+                required: false,
+                description: "Together model id, e.g. black-forest-labs/FLUX.1-schnell (default), black-forest-labs/FLUX.1-dev, ideogram/ideogram-3.0, Qwen/Qwen-Image",
+            },
+            size: {
+                type: "string",
+                required: false,
+                description: "WxH (default: 1024x1024)",
+            },
+            steps: {
+                type: "number",
+                required: false,
+                description: "Inference steps (default: 4 for FLUX.1-schnell). Use 20–30 for FLUX.1-dev or Ideogram.",
+            },
+            n: {
+                type: "number",
+                required: false,
+                description: "Number of images (default: 1, max: 4)",
+            },
+        },
+        async execute(input, ctx) {
+            const p = (input ?? {});
+            if (typeof p.prompt !== "string" || p.prompt.length === 0) {
+                throw new Error("together: prompt is required");
+            }
+            const apiKey = ctx.connection.config.apiKey;
+            const model = p.model ?? "black-forest-labs/FLUX.1-schnell";
+            const { width, height } = parseSize(p.size, "together");
+            const body = {
+                model,
+                prompt: p.prompt,
+                width,
+                height,
+                steps: p.steps ?? 4,
+                n: Math.min(p.n ?? 1, 4),
+                response_format: "base64",
+            };
+            const res = await fetch(ENDPOINT, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    Authorization: `Bearer ${apiKey}`,
+                },
+                body: JSON.stringify(body),
+            });
+            if (!res.ok) {
+                throw new Error(`Together 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: "together", model, images };
+        },
+    });
+}

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

@@ -0,0 +1,77 @@
+/**
+ * xAI image generation (Grok Imagine / Aurora) for runline.
+ *
+ *   await xai.image.create({ prompt: "ultra-realistic close-up of a dragonfly" })
+ *   await xai.image.create({ prompt: "movie poster", aspectRatio: "9:16" })
+ *
+ * Aurora leans photorealistic and handles real-world entities and
+ * text rendering well. Sized via aspect_ratio rather than W×H —
+ * the API does the math.
+ */
+const ENDPOINT = "https://api.x.ai/v1/images/generations";
+const MODEL = "grok-imagine-image";
+export default function xai(rl) {
+    rl.setName("xai");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        apiKey: {
+            type: "string",
+            required: true,
+            description: "xAI API key",
+            env: "XAI_API_KEY",
+        },
+    });
+    rl.registerAction("image.create", {
+        description: "Generate an image with xAI Grok Imagine (Aurora). Returns base64-encoded JPEGs and any revised prompt the model produced.",
+        inputSchema: {
+            prompt: {
+                type: "string",
+                required: true,
+                description: "Detailed description of the image",
+            },
+            aspectRatio: {
+                type: "string",
+                required: false,
+                description: "1:1 | 16:9 | 9:16 | 4:3 | 3:4 | 3:2 | 2:3 | auto (default: auto)",
+            },
+            n: {
+                type: "number",
+                required: false,
+                description: "Number of images (default: 1, max: 10)",
+            },
+        },
+        async execute(input, ctx) {
+            const p = (input ?? {});
+            if (typeof p.prompt !== "string" || p.prompt.length === 0) {
+                throw new Error("xai: prompt is required");
+            }
+            const apiKey = ctx.connection.config.apiKey;
+            const body = {
+                model: MODEL,
+                prompt: p.prompt,
+                n: Math.min(p.n ?? 1, 10),
+                response_format: "b64_json",
+            };
+            if (p.aspectRatio)
+                body.aspect_ratio = p.aspectRatio;
+            const res = await fetch(ENDPOINT, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    Authorization: `Bearer ${apiKey}`,
+                },
+                body: JSON.stringify(body),
+            });
+            if (!res.ok) {
+                throw new Error(`xAI API error ${res.status}: ${await res.text()}`);
+            }
+            const data = (await res.json());
+            const images = (data.data ?? []).map((d) => ({
+                base64: d.b64_json,
+                mimeType: "image/jpeg",
+                ...(d.revised_prompt ? { revisedPrompt: d.revised_prompt } : {}),
+            }));
+            return { provider: "xai", model: MODEL, images };
+        },
+    });
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "runline",
-  "version": "0.6.0",
-  "description": "Code mode for agents \u2014 turn any API or command into a callable action",
+  "version": "0.7.0",
+  "description": "Code mode for agents — turn any API or command into a callable action",
   "type": "module",
   "main": "dist/index.js",
   "exports": {