@bunny-agent/runner-cli 0.9.28 → 0.9.29-beta.0

package/dist/bundle.mjs

@@ -1406,18 +1406,139 @@ var generateImageSchema = {
   required: ["prompt"],
   additionalProperties: false
 };
-async function resolveB64(item) {
+async function resolveB64(item, apiKey) {
   if (item.b64_json)
     return item.b64_json;
-  if (item.url) {
-    const res = await fetch(item.url);
+  if (item.b64Json)
+    return item.b64Json;
+  if (item.image_base64)
+    return item.image_base64;
+  if (item.imageBase64)
+    return item.imageBase64;
+  if (item.base64)
+    return item.base64;
+  if (typeof item.image === "string")
+    return item.image;
+  if (item.image?.b64_json)
+    return item.image.b64_json;
+  if (item.image?.base64)
+    return item.image.base64;
+  const url = item.url ?? item.image_url ?? item.imageUrl ?? item.image?.url;
+  if (url) {
+    const headers = {};
+    if (apiKey) {
+      headers.Authorization = `Bearer ${apiKey}`;
+    }
+    const res = await fetch(url, { headers });
     if (res.ok)
       return Buffer.from(await res.arrayBuffer()).toString("base64");
   }
   return void 0;
 }
-async function saveImageItem(item, filePath) {
-  const b64 = await resolveB64(item);
+function pickImageItem(response) {
+  const tryFromObject = (value) => {
+    if (!value || typeof value !== "object")
+      return void 0;
+    const obj = value;
+    return {
+      b64_json: obj.b64_json ?? obj.b64Json,
+      b64Json: obj.b64Json,
+      url: obj.url ?? obj.imageUrl,
+      image_base64: obj.image_base64 ?? obj.imageBase64,
+      imageBase64: obj.imageBase64,
+      image_url: obj.image_url ?? obj.imageUrl,
+      imageUrl: obj.imageUrl,
+      base64: obj.base64,
+      image: obj.image
+    };
+  };
+  const asItem = (value) => {
+    if (value == null)
+      return void 0;
+    if (typeof value === "string") {
+      return { base64: value };
+    }
+    if (typeof value === "object") {
+      const normalized = tryFromObject(value);
+      if (normalized)
+        return normalized;
+    }
+    return void 0;
+  };
+  const fromDataArray = Array.isArray(response.data) ? asItem(response.data[0]) : void 0;
+  if (fromDataArray)
+    return fromDataArray;
+  const fromDataValue = asItem(response.data);
+  if (fromDataValue)
+    return fromDataValue;
+  const responseRecord = response;
+  const imagesValue = responseRecord.images;
+  const outputValue = responseRecord.output;
+  const fromImagesArray = Array.isArray(imagesValue) ? asItem(imagesValue[0]) : void 0;
+  if (fromImagesArray)
+    return fromImagesArray;
+  const fromImagesValue = asItem(imagesValue);
+  if (fromImagesValue)
+    return fromImagesValue;
+  const fromOutputArray = Array.isArray(outputValue) ? asItem(outputValue[0]) : void 0;
+  if (fromOutputArray)
+    return fromOutputArray;
+  const fromOutputValue = asItem(outputValue);
+  if (fromOutputValue)
+    return fromOutputValue;
+  const fromTopLevel = asItem(response);
+  if (fromTopLevel)
+    return fromTopLevel;
+  const queue = [response];
+  while (queue.length > 0) {
+    const current = queue.shift();
+    if (current == null)
+      continue;
+    if (typeof current === "string") {
+      if (/^[A-Za-z0-9+/=]{32,}$/.test(current))
+        return { base64: current };
+      continue;
+    }
+    if (typeof current !== "object")
+      continue;
+    const normalized = tryFromObject(current);
+    if (normalized) {
+      const hasUsefulField = Boolean(normalized.b64_json ?? normalized.b64Json ?? normalized.image_base64 ?? normalized.imageBase64 ?? normalized.base64 ?? normalized.url ?? normalized.image_url ?? normalized.imageUrl ?? (typeof normalized.image === "string" ? normalized.image : normalized.image?.b64_json ?? normalized.image?.base64 ?? normalized.image?.url));
+      if (hasUsefulField)
+        return normalized;
+    }
+    if (Array.isArray(current)) {
+      queue.push(...current);
+      continue;
+    }
+    for (const value of Object.values(current)) {
+      queue.push(value);
+    }
+  }
+  return {};
+}
+function detectImageMime(filePath) {
+  const ext = extname(filePath).toLowerCase();
+  if (ext === ".jpg" || ext === ".jpeg")
+    return "image/jpeg";
+  if (ext === ".webp")
+    return "image/webp";
+  if (ext === ".gif")
+    return "image/gif";
+  return "image/png";
+}
+function buildPolicySafeEditPrompt(prompt) {
+  const riskyPattern = /\b(watermark|watermarks|logo|logos|copyright|brand mark|remove branding)\b/i;
+  if (!riskyPattern.test(prompt)) {
+    return { prompt, rewritten: false };
+  }
+  return {
+    prompt: "Clean up distracting overlay text or marks naturally while preserving the original scene, style, and layout. Keep the result seamless and high quality.",
+    rewritten: true
+  };
+}
+async function saveImageItem(item, filePath, apiKey) {
+  const b64 = await resolveB64(item, apiKey);
   if (!b64)
     return void 0;
   mkdirSync2(dirname3(filePath), { recursive: true });
@@ -1458,20 +1579,22 @@ function buildImageGenerateTool(cwd, imageModelId, baseUrl, apiKey) {
             prompt,
             n: 1,
             size,
-            quality
+            quality,
+            response_format: "b64_json",
+            output_format: "png"
           })
         });
         if (!res.ok) {
           throw new Error(`Image generation failed (${res.status}): ${await res.text()}`);
         }
         const json = await res.json();
-        const item = json.data?.[0] ?? {};
-        const savedPath = await saveImageItem(item, filePath);
+        const item = pickImageItem(json);
+        const savedPath = await saveImageItem(item, filePath, apiKey);
         return {
           content: [
             {
               type: "text",
-              text: savedPath ?? "Image generated but could not be saved."
+              text: savedPath ?? `Image generated but could not be saved: no image payload returned; image_model: ${imageModelId}`
             }
           ],
           details: {
@@ -1491,6 +1614,192 @@ function buildImageGenerateTool(cwd, imageModelId, baseUrl, apiKey) {
     }
   };
 }
+var editImageSchema = {
+  type: "object",
+  properties: {
+    image: {
+      type: "string",
+      description: "Path to the source image file to edit (relative to working directory or absolute)."
+    },
+    prompt: {
+      type: "string",
+      description: "Text description of the desired final image. Describe the full result, not just the change."
+    },
+    mask: {
+      type: "string",
+      description: "Optional path to a mask image (PNG with transparent areas indicating where to edit). If omitted, the model decides what to change based on the prompt."
+    },
+    filename: {
+      type: "string",
+      description: "Output filename with extension, e.g. 'edited_cat.png'. Defaults to a timestamp-based name."
+    },
+    size: {
+      type: "string",
+      enum: ["1024x1024", "1024x1536", "1536x1024", "auto"],
+      description: "Output image dimensions. Optional; omit or set auto to let model decide."
+    },
+    quality: {
+      type: "string",
+      enum: ["low", "medium", "high", "auto"],
+      description: "Image quality. Optional; omit or set auto to let model decide."
+    }
+  },
+  required: ["image", "prompt"],
+  additionalProperties: false
+};
+function buildMultipartBody(fields, files) {
+  const boundary = `----SandagentBoundary${Date.now()}${Math.random().toString(36).slice(2)}`;
+  const parts = [];
+  for (const { name, value } of fields) {
+    parts.push(Buffer.from(`--${boundary}\r
+Content-Disposition: form-data; name="${name}"\r
+\r
+${value}\r
+`));
+  }
+  for (const { name, filename, buffer, mime } of files) {
+    parts.push(Buffer.from(`--${boundary}\r
+Content-Disposition: form-data; name="${name}"; filename="${filename}"\r
+Content-Type: ${mime}\r
+\r
+`));
+    parts.push(buffer);
+    parts.push(Buffer.from("\r\n"));
+  }
+  parts.push(Buffer.from(`--${boundary}--\r
+`));
+  return {
+    body: Buffer.concat(parts),
+    contentType: `multipart/form-data; boundary=${boundary}`
+  };
+}
+function buildImageEditTool(cwd, imageModelId, baseUrl, apiKey) {
+  return {
+    name: "edit_image",
+    label: "edit image",
+    description: "Edit an existing image based on a text prompt. Optionally use a mask to control which areas to modify. Saves the result to disk and returns the file path.",
+    promptSnippet: "edit_image(image, prompt, mask?, filename?, size?, quality?) - edit an existing image",
+    promptGuidelines: [
+      "Use edit_image when the user wants to modify, retouch, or transform an existing image.",
+      "The prompt should describe the full desired final image, not just the change.",
+      "Provide the source image path. Use a mask image (PNG with transparent areas) to control where edits happen.",
+      "Without a mask, the model decides what to change based on the prompt."
+    ],
+    // biome-ignore lint/suspicious/noExplicitAny: plain JSON Schema compatible with TypeBox TSchema
+    parameters: editImageSchema,
+    async execute(_toolCallId, params, _signal, _onUpdate) {
+      const { readFileSync: readFileSync4, existsSync: existsSync8 } = await import("node:fs");
+      const { resolve: resolve4, basename: basename2 } = await import("node:path");
+      const p = params;
+      const imagePath = p.image;
+      const prompt = p.prompt;
+      const maskPath = p.mask;
+      const size = p.size;
+      const quality = p.quality;
+      const rawFilename = p.filename;
+      const safePrompt = buildPolicySafeEditPrompt(prompt);
+      const resolvedImage = resolve4(cwd, imagePath);
+      if (!existsSync8(resolvedImage)) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Image edit error: source image not found at ${resolvedImage}`
+            }
+          ],
+          details: void 0
+        };
+      }
+      const filename = rawFilename ? extname(rawFilename) ? rawFilename : `${rawFilename}.png` : `edited_${Date.now()}.png`;
+      const filePath = join6(cwd, filename.replace(/[^a-zA-Z0-9_\-./]/g, "_"));
+      try {
+        const imageBuffer = readFileSync4(resolvedImage);
+        const fields = [
+          { name: "model", value: imageModelId },
+          { name: "prompt", value: safePrompt.prompt },
+          { name: "n", value: "1" },
+          { name: "response_format", value: "b64_json" },
+          { name: "output_format", value: "png" }
+        ];
+        if (size && size !== "auto") {
+          fields.push({ name: "size", value: size });
+        }
+        if (quality && quality !== "auto") {
+          fields.push({ name: "quality", value: quality });
+        }
+        const files = [
+          {
+            name: "image",
+            filename: basename2(resolvedImage),
+            buffer: imageBuffer,
+            mime: detectImageMime(resolvedImage)
+          }
+        ];
+        if (maskPath) {
+          const resolvedMask = resolve4(cwd, maskPath);
+          if (existsSync8(resolvedMask)) {
+            files.push({
+              name: "mask",
+              filename: basename2(resolvedMask),
+              buffer: readFileSync4(resolvedMask),
+              mime: detectImageMime(resolvedMask)
+            });
+          }
+        }
+        const { body: multipartBody, contentType } = buildMultipartBody(fields, files);
+        const url = `${baseUrl.replace(/\/$/, "")}/v1/images/edits`;
+        const sendRequest = async (body, type) => {
+          const res = await fetch(url, {
+            method: "POST",
+            headers: {
+              "Content-Type": type,
+              Authorization: `Bearer ${apiKey}`
+            },
+            body
+          });
+          if (!res.ok) {
+            throw new Error(`Image edit failed (${res.status}): ${await res.text()}`);
+          }
+          return await res.json();
+        };
+        let json = await sendRequest(multipartBody, contentType);
+        const item = pickImageItem(json);
+        let savedPath = await saveImageItem(item, filePath, apiKey);
+        const firstResponseHasEmptyDataArray = Array.isArray(json.data) && json.data.length === 0;
+        if (!savedPath && safePrompt.rewritten && firstResponseHasEmptyDataArray) {
+          const retryFields = fields.map((f) => f.name === "prompt" ? {
+            name: "prompt",
+            value: "Remove only distracting overlay text artifacts naturally and keep all original content unchanged."
+          } : f);
+          const retryMultipart = buildMultipartBody(retryFields, files);
+          json = await sendRequest(retryMultipart.body, retryMultipart.contentType);
+          const retryItem = pickImageItem(json);
+          savedPath = await saveImageItem(retryItem, filePath, apiKey);
+        }
+        return {
+          content: [
+            {
+              type: "text",
+              text: savedPath ?? `Image edited but could not be saved: no image payload returned; image_model: ${imageModelId}`
+            }
+          ],
+          details: {
+            filePath: savedPath,
+            response: json
+          }
+        };
+      } catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        return {
+          content: [
+            { type: "text", text: `Image edit error: ${msg}` }
+          ],
+          details: void 0
+        };
+      }
+    }
+  };
+}
 
 // ../../packages/runner-pi/dist/tool-overrides.js
 import { createBashTool, createReadTool } from "@mariozechner/pi-coding-agent";
@@ -2065,7 +2374,7 @@ function createPiRunner(options = {}) {
         const customTools = options.env && Object.keys(options.env).length > 0 ? buildSecretAwareTools(cwd, options.env) : [];
         if (imageModelName) {
           const apiKey = await modelRegistry.authStorage.getApiKey(provider) ?? "";
-          customTools.push(buildImageGenerateTool(cwd, imageModelName, model.baseUrl, apiKey));
+          customTools.push(buildImageGenerateTool(cwd, imageModelName, model.baseUrl, apiKey), buildImageEditTool(cwd, imageModelName, model.baseUrl, apiKey));
         }
         const { session } = await createAgentSession({
           cwd,
@@ -2236,7 +2545,7 @@ function createPiRunner(options = {}) {
                 if (options.env && Object.keys(options.env).length > 0) {
                   output = redactSecrets(output, options.env);
                 }
-                if (event.toolName === "generate_image" && event.result !== null && typeof event.result === "object") {
+                if ((event.toolName === "generate_image" || event.toolName === "edit_image") && event.result !== null && typeof event.result === "object") {
                   const details = event.result.details;
                   const u = details?.response?.usage;
                   if (u) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bunny-agent/runner-cli",
-  "version": "0.9.28",
+  "version": "0.9.29-beta.0",
   "description": "BunnyAgent Runner CLI - Like gemini-cli or claude-code, runs in your local terminal with AI SDK UI streaming",
   "type": "module",
   "bin": {
@@ -53,12 +53,12 @@
     "esbuild": "^0.27.2",
     "typescript": "^5.3.0",
     "vitest": "^1.6.1",
-    "@bunny-agent/runner-harness": "0.1.1-beta.0",
     "@bunny-agent/runner-claude": "0.6.2",
     "@bunny-agent/runner-codex": "0.6.2",
-    "@bunny-agent/runner-gemini": "0.6.2",
+    "@bunny-agent/runner-harness": "0.1.1-beta.0",
     "@bunny-agent/runner-opencode": "0.6.2",
-    "@bunny-agent/runner-pi": "0.6.4-beta.0"
+    "@bunny-agent/runner-pi": "0.6.4-beta.0",
+    "@bunny-agent/runner-gemini": "0.6.2"
   },
   "scripts": {
     "build": "tsc && pnpm bundle",