runline 0.27.1 → 0.28.0

package/dist/core/engine.js

@@ -459,6 +459,12 @@ function formatError(cause) {
 // code gets a cwd-relative `require`, so a bare specifier would resolve
 // against the caller's cwd instead of runline's own node_modules.
 const ferrosearchPath = createRequire(import.meta.url).resolve("@shift-labs/ferrosearch");
+// typebox ships ESM only; require() of an .mjs works everywhere runline
+// runs (bun, and node since 22.12's require(esm)). Resolved host-side
+// for the same reason as ferrosearch: eval'd worker code gets a
+// cwd-relative require, so a bare specifier would resolve against the
+// caller's cwd instead of runline's own node_modules.
+const typeboxValuePath = createRequire(import.meta.url).resolve("typebox/value");
 function buildHelpData(plugins) {
     const data = {};
     for (const p of plugins) {
@@ -467,6 +473,7 @@ function buildHelpData(plugins) {
             access: a.access,
             description: a.description,
             inputs: helpInputs(a.inputSchema),
+            ...(isTypedInputSchema(a.inputSchema) ? { schema: a.inputSchema } : {}),
         }));
     }
     return data;
@@ -594,6 +601,9 @@ const __toJson = (v) => v === undefined ? undefined : JSON.parse(JSON.stringify(
 // also means an index built by agent code is invisible to that limit.
 const { FerroSearch } = require(${JSON.stringify(ferrosearchPath)});
 
+// The host's own validator, for actions.check on typed schemas.
+const { Check: __schemaCheck, Errors: __schemaErrors } = require(${JSON.stringify(typeboxValuePath)});
+
 const __help = ${JSON.stringify(helpData)};
 
 const __makeProxy = (path = []) => new Proxy(() => undefined, {
@@ -653,6 +663,82 @@ const __search = (() => {
   return index;
 })();
 
+// instancePath "/members/0/externalId" → ["members", "0", "externalId"],
+// with JSON-pointer escapes (~1 for /, ~0 for ~) undone per part.
+const __pointerParts = (instancePath) =>
+  String(instancePath || '').split('/').filter((p) => p.length)
+    .map((p) => p.replace(/~1/g, '/').replace(/~0/g, '~'));
+
+// ["members", "0", "externalId"] → "members[0].externalId"
+const __fieldPath = (instancePath, prop) => {
+  const parts = __pointerParts(instancePath);
+  if (prop !== undefined) parts.push(String(prop));
+  let out = '';
+  for (const part of parts) {
+    if (/^\\d+$/.test(part)) out += '[' + part + ']';
+    else out += out ? '.' + part : part;
+  }
+  return out;
+};
+
+const __valueAt = (root, instancePath) => {
+  let v = root;
+  for (const part of __pointerParts(instancePath)) {
+    if (v == null) return undefined;
+    v = v[part];
+  }
+  return v;
+};
+
+const __valueType = (v) => v === null ? 'null' : Array.isArray(v) ? 'array' : typeof v;
+
+// Deep validation for typed schemas (SHFT-1187): the same Check/Errors
+// the host runs before execute, on the same schema, so the preflight
+// verdict and the execution verdict cannot diverge. The familiar
+// missing/unknown/typeErrors buckets are derived from the validator's
+// structured errors — keyword and params, never message parsing — and
+// the errors array carries each raw "<path> <message>" line exactly as
+// a rejected execution would report it. Grouping type errors by instance
+// path keeps a failed union one typeError instead of one per branch.
+const __checkTyped = (entry, provided, signature) => {
+  if (__schemaCheck(entry.schema, provided)) {
+    return { ok: true, missing: [], unknown: [], typeErrors: [], errors: [], signature };
+  }
+  const missing = [];
+  const unknown = [];
+  const errors = [];
+  const byPath = new Map();
+  for (const err of __schemaErrors(entry.schema, provided)) {
+    errors.push((err.instancePath || '/') + ' ' + err.message);
+    const params = err.params || {};
+    if (err.keyword === 'required') {
+      for (const prop of params.requiredProperties || []) missing.push(__fieldPath(err.instancePath, prop));
+    } else if (err.keyword === 'additionalProperties') {
+      for (const prop of params.additionalProperties || []) unknown.push(__fieldPath(err.instancePath, prop));
+    } else {
+      const group = byPath.get(err.instancePath) || [];
+      group.push(err);
+      byPath.set(err.instancePath, group);
+    }
+  }
+  const typeErrors = [];
+  for (const [instancePath, group] of byPath) {
+    const field = __fieldPath(instancePath) || '(input)';
+    const value = __valueAt(provided, instancePath);
+    const consts = group.filter((e) => e.keyword === 'const' && 'allowedValue' in (e.params || {}));
+    const typeErr = group.find((e) => e.keyword === 'type' && (e.params || {}).type);
+    if (consts.length) {
+      // A union of literals: the branches ARE the allowed values.
+      typeErrors.push({ field, expected: consts.map((e) => String(e.params.allowedValue)).join(' | '), actual: __fmt(value) });
+    } else if (typeErr) {
+      typeErrors.push({ field, expected: String(typeErr.params.type), actual: __valueType(value) });
+    } else {
+      typeErrors.push({ field, expected: group[0].message, actual: __fmt(value) });
+    }
+  }
+  return { ok: false, missing, unknown, typeErrors, errors, signature };
+};
+
 const __actionsApi = {
   list(plugin) {
     const paths = Object.keys(__index);
@@ -691,6 +777,13 @@ const __actionsApi = {
       const near = __actionsApi.find(path, 3).map((n) => n.path);
       return { ok: false, error: 'Unknown action: ' + path, suggestions: near };
     }
+    const signature = __formatSignature(hit.plugin, hit.entry);
+    if (hit.entry.schema) {
+      // Mirror the host's normalizeActionInput: a check with no args is
+      // a call with an empty argument set; anything else — null, a
+      // scalar — is validated as given, exactly as execute would.
+      return __checkTyped(hit.entry, args === undefined ? {} : args, signature);
+    }
     const inputs = hit.entry.inputs || {};
     const provided = args && typeof args === 'object' ? args : {};
     const missing = [];
@@ -719,7 +812,8 @@ const __actionsApi = {
       missing,
       unknown,
       typeErrors,
-      signature: __formatSignature(hit.plugin, hit.entry),
+      errors: [],
+      signature,
     };
   },
 };

package/dist/plugins/_shared/imageFile.js

@@ -8,9 +8,9 @@
  * send_file/attachment tool. Plugins load in-process via jiti, so node:fs is
  * available (same pattern as googleDrive/googleSlides).
  */
-import { writeFileSync } from "node:fs";
+import { readFileSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
-import { join } from "node:path";
+import { basename, extname, join } from "node:path";
 const MIME_EXT = {
     "image/png": "png",
     "image/jpeg": "jpg",
@@ -38,3 +38,38 @@ export function writeImageFile(opts) {
     return { path, mimeType, byteLength: bytes.length };
 }
 export const SEND_FILE_NOTE = "Image(s) written to disk. Deliver each to the user with send_file using its `path`.";
+const EXT_MIME = {
+    png: "image/png",
+    jpg: "image/jpeg",
+    jpeg: "image/jpeg",
+    webp: "image/webp",
+    gif: "image/gif",
+};
+/**
+ * Read a local image for an `image.edit` call: bytes + base64 + mime
+ * (from the extension) + a `data:` URI for JSON APIs. Throws with the
+ * plugin's name when the file can't be read so errors point at the
+ * right tool.
+ */
+export function readImageInput(imagePath, pluginName) {
+    if (typeof imagePath !== "string" || imagePath.trim().length === 0) {
+        throw new Error(`${pluginName}: imagePath is required`);
+    }
+    let bytes;
+    try {
+        bytes = readFileSync(imagePath);
+    }
+    catch (err) {
+        throw new Error(`${pluginName}: cannot read image at ${imagePath} — ${err instanceof Error ? err.message : String(err)}`);
+    }
+    const ext = extname(imagePath).slice(1).toLowerCase();
+    const mimeType = EXT_MIME[ext] ?? "image/png";
+    const base64 = bytes.toString("base64");
+    return {
+        bytes,
+        base64,
+        mimeType,
+        dataUri: `data:${mimeType};base64,${base64}`,
+        fileName: basename(imagePath),
+    };
+}

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

@@ -14,14 +14,32 @@
  * 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.
+ * Nano Banana is strong at editing — `image.edit` sends a local image
+ * inline next to the instruction and writes the edited result to disk.
  */
-import { writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
 import * as t from "typebox";
+import { readImageInput, SEND_FILE_NOTE, writeImageFile, } from "../../_shared/imageFile.js";
 const BASE = "https://generativelanguage.googleapis.com/v1beta/models";
+/** Write every inline image part of a Gemini response to disk. */
+function saveInlineImages(data, saveDir) {
+    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(writeImageFile({
+                    base64: part.inlineData.data,
+                    mimeType: part.inlineData.mimeType ?? "image/png",
+                    provider: "googleImage",
+                    index: images.length,
+                    saveDir,
+                    stamp,
+                }));
+            }
+        }
+    }
+    return images;
+}
 export default function googleImage(rl) {
     rl.setName("googleImage");
     rl.setVersion("0.1.0");
@@ -70,27 +88,64 @@ 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) {
-                        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 });
-                    }
-                }
+            const images = saveInlineImages(data, p.saveDir);
+            return { provider: "googleImage", model, images, note: SEND_FILE_NOTE };
+        },
+    });
+    rl.registerAction("image.edit", {
+        access: "write",
+        description: "Edit a local image with Gemini (Nano Banana): give the file path and describe the change. Sends the image inline with the instruction, writes the edited image(s) to disk, and returns their file `path`s — not base64. Deliver each with send_file using its `path`.",
+        inputSchema: t.Object({
+            prompt: t.String({
+                minLength: 1,
+                description: "Instruction describing the edit to apply",
+            }),
+            imagePath: t.String({
+                minLength: 1,
+                description: "Path to the source image file",
+            }),
+            model: t.Optional(t.String({
+                minLength: 1,
+                description: "Gemini image model ID. Defaults to gemini-2.5-flash-image.",
+            })),
+            saveDir: t.Optional(t.String({
+                description: "Directory to write the image file(s) into. Empty or omitted uses the OS temp directory.",
+            })),
+        }, { additionalProperties: false }),
+        async execute(input, ctx) {
+            const p = (input ?? {});
+            if (typeof p.prompt !== "string" || p.prompt.length === 0) {
+                throw new Error("googleImage: prompt is required");
             }
-            return {
-                provider: "googleImage",
-                model,
-                images,
-                note: "Image(s) written to disk. Deliver each to the user with send_file using its `path`.",
+            const img = readImageInput(p.imagePath, "googleImage");
+            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 },
+                            { inlineData: { mimeType: img.mimeType, data: img.base64 } },
+                        ],
+                    },
+                ],
+                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 = saveInlineImages(data, p.saveDir);
+            if (images.length === 0) {
+                throw new Error("googleImage: the model returned no edited image — it may have refused; try a more specific instruction");
+            }
+            return { provider: "googleImage", model, images, note: SEND_FILE_NOTE };
         },
     });
 }

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

@@ -14,10 +14,9 @@
  *   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";
+import { readImageInput, SEND_FILE_NOTE, writeImageFile, } from "../../_shared/imageFile.js";
 const ENDPOINT = "https://api.openai.com/v1/images/generations";
+const EDIT_ENDPOINT = "https://api.openai.com/v1/images/edits";
 export default function openai(rl) {
     rl.setName("openai");
     rl.setVersion("0.1.0");
@@ -114,25 +113,117 @@ export default function openai(rl) {
                 throw new Error(`OpenAI 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 = (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,
+            const images = (data.data ?? []).map((d, i) => ({
+                ...writeImageFile({
+                    base64: d.b64_json,
                     mimeType: "image/png",
-                    byteLength: bytes.length,
-                    ...(d.revised_prompt ? { revisedPrompt: d.revised_prompt } : {}),
-                };
+                    provider: "openai-image",
+                    index: i,
+                    saveDir: p.saveDir,
+                    stamp,
+                }),
+                ...(d.revised_prompt ? { revisedPrompt: d.revised_prompt } : {}),
+            }));
+            return { provider: "openai", model, images, note: SEND_FILE_NOTE };
+        },
+    });
+    rl.registerAction("image.edit", {
+        access: "write",
+        description: "Edit a local image with OpenAI (gpt-image-*) via /v1/images/edits: give the file path(s) and describe the change. Writes the edited PNG(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: "Instruction describing the edit to apply",
+            },
+            imagePath: {
+                type: "string",
+                required: false,
+                description: "Path to the source image file. Either this or imagePaths is required.",
+            },
+            imagePaths: {
+                type: "array",
+                required: false,
+                description: "Paths to multiple source images (gpt-image models accept up to 16; the first is the primary).",
+            },
+            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-2 | gpt-image-1 | gpt-image-1-mini. Omit to use the connection default.",
+            },
+            size: {
+                type: "string",
+                required: false,
+                description: "WxH output size. Omit to let the API match the input.",
+            },
+            quality: {
+                type: "string",
+                required: false,
+                description: "low | medium | high",
+            },
+            n: {
+                type: "number",
+                required: false,
+                description: "Number of edited variants (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 paths = Array.isArray(p.imagePaths) && p.imagePaths.length > 0
+                ? p.imagePaths
+                : p.imagePath
+                    ? [p.imagePath]
+                    : [];
+            if (paths.length === 0) {
+                throw new Error("openai: imagePath (or imagePaths) is required");
+            }
+            const apiKey = ctx.connection.config.apiKey;
+            const model = p.model ??
+                ctx.connection.config.defaultModel ??
+                "gpt-image-1";
+            const form = new FormData();
+            form.append("model", model);
+            form.append("prompt", p.prompt);
+            form.append("n", String(Math.min(p.n ?? 1, 4)));
+            if (p.size)
+                form.append("size", p.size);
+            if (p.quality)
+                form.append("quality", p.quality);
+            for (const path of paths) {
+                const img = readImageInput(path, "openai");
+                form.append("image[]", new Blob([img.bytes], { type: img.mimeType }), img.fileName);
+            }
+            const res = await fetch(EDIT_ENDPOINT, {
+                method: "POST",
+                headers: { Authorization: `Bearer ${apiKey}` },
+                body: form,
             });
-            return {
-                provider: "openai",
-                model,
-                images,
-                note: "Image(s) written to disk. Deliver each to the user with send_file using its `path`.",
-            };
+            if (!res.ok) {
+                throw new Error(`OpenAI API error ${res.status}: ${await res.text()}`);
+            }
+            const data = (await res.json());
+            const stamp = Date.now();
+            const images = (data.data ?? []).map((d, i) => ({
+                ...writeImageFile({
+                    base64: d.b64_json,
+                    mimeType: "image/png",
+                    provider: "openai-image",
+                    index: i,
+                    saveDir: p.saveDir,
+                    stamp,
+                }),
+                ...(d.revised_prompt ? { revisedPrompt: d.revised_prompt } : {}),
+            }));
+            return { provider: "openai", model, images, note: SEND_FILE_NOTE };
         },
     });
 }

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

@@ -13,8 +13,9 @@
  * 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";
+import { readImageInput, SEND_FILE_NOTE, writeImageFile } from "../../_shared/imageFile.js";
 const ENDPOINT = "https://external.api.recraft.ai/v1/images/generations";
+const EDIT_ENDPOINT = "https://external.api.recraft.ai/v1/images/imageToImage";
 export default function recraft(rl) {
     rl.setName("recraft");
     rl.setVersion("0.1.0");
@@ -102,4 +103,83 @@ export default function recraft(rl) {
             return { provider: "recraft", model, images, note: SEND_FILE_NOTE };
         },
     });
+    rl.registerAction("image.edit", {
+        access: "write",
+        description: "Edit a local image with Recraft (imageToImage): give the file path, describe the change, and tune `strength` for how far to depart from the original. Writes the edited 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: "Instruction describing the transformation",
+            },
+            imagePath: {
+                type: "string",
+                required: true,
+                description: "Path to the source image file (PNG, JPG, WEBP, or SVG; max 10 MB)",
+            },
+            strength: {
+                type: "number",
+                required: false,
+                description: "0–1: how strongly to alter the input (default: 0.2 — close to the original)",
+            },
+            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: "Any Recraft V3 / V4 / V4.1 model, raster or vector (e.g. recraftv3, recraftv4_pro, recraftv4_1_vector). API default: recraftv4_1.",
+            },
+            style: {
+                type: "string",
+                required: false,
+                description: "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",
+            },
+            n: {
+                type: "number",
+                required: false,
+                description: "Number of edited variants (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 img = readImageInput(p.imagePath, "recraft");
+            const apiKey = ctx.connection.config.apiKey;
+            const form = new FormData();
+            form.append("image", new Blob([img.bytes], { type: img.mimeType }), img.fileName);
+            form.append("prompt", p.prompt);
+            form.append("strength", String(p.strength ?? 0.2));
+            form.append("response_format", "b64_json");
+            form.append("n", String(Math.min(p.n ?? 1, 6)));
+            if (p.model)
+                form.append("model", p.model);
+            if (p.style)
+                form.append("style", p.style);
+            if (p.styleId)
+                form.append("style_id", p.styleId);
+            const res = await fetch(EDIT_ENDPOINT, {
+                method: "POST",
+                headers: { Authorization: `Bearer ${apiKey}` },
+                body: form,
+            });
+            if (!res.ok) {
+                throw new Error(`Recraft API error ${res.status}: ${await res.text()}`);
+            }
+            const data = (await res.json());
+            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 }));
+            // The imageToImage endpoint's own default model is recraftv4_1.
+            return { provider: "recraft", model: p.model ?? "recraftv4_1", images, note: SEND_FILE_NOTE };
+        },
+    });
 }

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

@@ -19,7 +19,7 @@
  * separately.
  */
 import { Buffer } from "node:buffer";
-import { SEND_FILE_NOTE, writeImageFile } from "../../_shared/imageFile.js";
+import { readImageInput, 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;
@@ -35,6 +35,93 @@ function stringifyError(err) {
         return String(err);
     }
 }
+/**
+ * Create a prediction for `model`, wait for it to reach a terminal
+ * state (Prefer: wait + polling), download the output URL(s), and
+ * write them to disk. Shared by image.create and image.edit — the
+ * only thing that differs between them is the prediction `input`.
+ */
+async function runPrediction(opts) {
+    const { apiToken, model, input, timeoutMs, saveDir } = opts;
+    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 }),
+    });
+    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 = [];
+    const stamp = Date.now();
+    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(writeImageFile({
+            base64: buf.toString("base64"),
+            mimeType: contentType,
+            provider: "replicate",
+            index: images.length,
+            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}`);
+    }
+    return { images, failures };
+}
 export default function replicate(rl) {
     rl.setName("replicate");
     rl.setVersion("0.1.0");
@@ -89,91 +176,78 @@ export default function replicate(rl) {
             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",
+            const { images, failures } = await runPrediction({
+                apiToken,
+                model,
+                input: {
+                    prompt: p.prompt,
+                    width,
+                    height,
+                    num_outputs: Math.min(p.n ?? 1, 4),
                 },
-                body: JSON.stringify({
-                    input: {
-                        prompt: p.prompt,
-                        width,
-                        height,
-                        num_outputs: Math.min(p.n ?? 1, 4),
-                    },
-                }),
+                timeoutMs: p.timeoutMs ?? DEFAULT_TIMEOUT_MS,
+                saveDir: p.saveDir,
             });
-            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 = [];
-            const stamp = Date.now();
-            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(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, note: SEND_FILE_NOTE };
+            if (failures.length > 0)
+                result.failures = failures;
+            return result;
+        },
+    });
+    rl.registerAction("image.edit", {
+        access: "write",
+        description: "Edit a local image via Replicate: give the file path and describe the change. Default model is black-forest-labs/flux-kontext-pro (input key `input_image`); other models may name their image input differently — override with `imageInputKey` (e.g. google/nano-banana uses `image_input`, which is sent as an array). Writes the edited 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: "Instruction describing the edit to apply",
+            },
+            imagePath: {
+                type: "string",
+                required: true,
+                description: "Path to the source image file (jpeg/png/gif/webp). Sent as a data URI — Replicate recommends hosted URLs for files over ~256 KB, so very large images may be rejected.",
+            },
+            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: "Edit-capable Replicate model id, e.g. black-forest-labs/flux-kontext-pro (default), black-forest-labs/flux-kontext-max, google/nano-banana",
+            },
+            imageInputKey: {
+                type: "string",
+                required: false,
+                description: "Name of the model's image input field (default: input_image). Keys ending in `_input` are sent as an array.",
+            },
+            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 img = readImageInput(p.imagePath, "replicate");
+            const apiToken = ctx.connection.config.apiToken;
+            const model = p.model ?? "black-forest-labs/flux-kontext-pro";
+            const imageKey = p.imageInputKey ?? "input_image";
+            const { images, failures } = await runPrediction({
+                apiToken,
+                model,
+                input: {
+                    prompt: p.prompt,
+                    [imageKey]: imageKey.endsWith("_input") ? [img.dataUri] : img.dataUri,
+                },
+                timeoutMs: p.timeoutMs ?? DEFAULT_TIMEOUT_MS,
+                saveDir: p.saveDir,
+            });
             const result = { provider: "replicate", model, images, note: SEND_FILE_NOTE };
             if (failures.length > 0)
                 result.failures = failures;

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

@@ -12,7 +12,7 @@
  * fidelity switch to FLUX.1-dev / Ideogram / Qwen-Image and bump
  * `steps` accordingly (20–30 is typical for non-schnell models).
  */
-import { SEND_FILE_NOTE, writeImageFile } from "../../_shared/imageFile.js";
+import { readImageInput, SEND_FILE_NOTE, writeImageFile } from "../../_shared/imageFile.js";
 import { parseSize } from "../../_shared/parseSize.js";
 const ENDPOINT = "https://api.together.xyz/v1/images/generations";
 export default function together(rl) {
@@ -95,4 +95,72 @@ export default function together(rl) {
             return { provider: "together", model, images, note: SEND_FILE_NOTE };
         },
     });
+    rl.registerAction("image.edit", {
+        access: "write",
+        description: "Edit a local image with Together AI (FLUX.1 Kontext): give the file path and describe the change. Sends the image as a data URI via `image_url` on the generations endpoint, writes the edited 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: "Instruction describing the edit to apply",
+            },
+            imagePath: {
+                type: "string",
+                required: true,
+                description: "Path to the source image file",
+            },
+            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: "Edit-capable model, e.g. black-forest-labs/FLUX.1-kontext-pro (default), black-forest-labs/FLUX.1-kontext-max",
+            },
+            steps: {
+                type: "number",
+                required: false,
+                description: "Inference steps (default: 28)",
+            },
+            n: {
+                type: "number",
+                required: false,
+                description: "Number of edited variants (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 img = readImageInput(p.imagePath, "together");
+            const apiKey = ctx.connection.config.apiKey;
+            const model = p.model ?? "black-forest-labs/FLUX.1-kontext-pro";
+            const body = {
+                model,
+                prompt: p.prompt,
+                image_url: img.dataUri,
+                steps: p.steps ?? 28,
+                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 stamp = Date.now();
+            const images = (data.data ?? []).map((d, i) => writeImageFile({ base64: d.b64_json, mimeType: "image/png", provider: "together", index: i, saveDir: p.saveDir, stamp }));
+            return { provider: "together", model, images, note: SEND_FILE_NOTE };
+        },
+    });
 }

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

@@ -8,9 +8,11 @@
  * text rendering well. Sized via aspect_ratio rather than W×H —
  * the API does the math.
  */
-import { SEND_FILE_NOTE, writeImageFile } from "../../_shared/imageFile.js";
+import { readImageInput, SEND_FILE_NOTE, writeImageFile } from "../../_shared/imageFile.js";
 const ENDPOINT = "https://api.x.ai/v1/images/generations";
+const EDIT_ENDPOINT = "https://api.x.ai/v1/images/edits";
 const MODEL = "grok-imagine-image";
+const EDIT_MODEL = "grok-imagine-image-2.0";
 export default function xai(rl) {
     rl.setName("xai");
     rl.setVersion("0.1.0");
@@ -75,10 +77,74 @@ export default function xai(rl) {
             const data = (await res.json());
             const stamp = Date.now();
             const images = (data.data ?? []).map((d, i) => ({
-                ...writeImageFile({ base64: d.b64_json, mimeType: "image/jpeg", provider: "xai", index: i, saveDir: p.saveDir, stamp }),
+                ...writeImageFile({ base64: d.b64_json, mimeType: d.mime_type ?? "image/jpeg", provider: "xai", index: i, saveDir: p.saveDir, stamp }),
                 ...(d.revised_prompt ? { revisedPrompt: d.revised_prompt } : {}),
             }));
             return { provider: "xai", model: MODEL, images, note: SEND_FILE_NOTE };
         },
     });
+    rl.registerAction("image.edit", {
+        access: "write",
+        description: "Edit a local image with xAI Grok Imagine: give the file path and describe the change. Sends the image as a data URI to /v1/images/edits (JSON, not multipart), writes the edited 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: "Instruction describing the edit to apply",
+            },
+            imagePath: {
+                type: "string",
+                required: true,
+                description: "Path to the source image file",
+            },
+            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: "Edit-capable model (default: grok-imagine-image-2.0)",
+            },
+            n: {
+                type: "number",
+                required: false,
+                description: "Number of edited variants (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 img = readImageInput(p.imagePath, "xai");
+            const apiKey = ctx.connection.config.apiKey;
+            const model = p.model ?? EDIT_MODEL;
+            const res = await fetch(EDIT_ENDPOINT, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    Authorization: `Bearer ${apiKey}`,
+                },
+                body: JSON.stringify({
+                    model,
+                    prompt: p.prompt,
+                    image: { url: img.dataUri },
+                    n: Math.min(p.n ?? 1, 10),
+                    response_format: "b64_json",
+                }),
+            });
+            if (!res.ok) {
+                throw new Error(`xAI API error ${res.status}: ${await res.text()}`);
+            }
+            const data = (await res.json());
+            const stamp = Date.now();
+            const images = (data.data ?? []).map((d, i) => ({
+                ...writeImageFile({ base64: d.b64_json, mimeType: d.mime_type ?? "image/jpeg", provider: "xai", index: i, saveDir: p.saveDir, stamp }),
+                ...(d.revised_prompt ? { revisedPrompt: d.revised_prompt } : {}),
+            }));
+            return { provider: "xai", model, images, note: SEND_FILE_NOTE };
+        },
+    });
 }

package/package.json

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