u-foo 3.0.2 → 3.0.3

package/src/code/nativeRunner.js

@@ -50,12 +50,14 @@ const {
 } = require("./protocol");
 const { stableStringify } = require("./context/stableJson");
 const { getReadToolDescription } = require("../agents/prompts/native/toolDescriptions/read");
+const { getReadImageToolDescription } = require("../agents/prompts/native/toolDescriptions/readImage");
 const { getWriteToolDescription } = require("../agents/prompts/native/toolDescriptions/write");
 const { getEditToolDescription } = require("../agents/prompts/native/toolDescriptions/edit");
 const { getBashToolDescription } = require("../agents/prompts/native/toolDescriptions/bash");
 
 const CORE_TOOL_NAMES = new Set([
   "read",
+  "read_image",
   "write",
   "edit",
   "bash",
@@ -64,7 +66,14 @@ const CORE_TOOL_NAMES = new Set([
   "task_run",
   "ask_user",
 ]);
-const EXECUTABLE_GRAPH_TOOLS = new Set(["read", "write", "edit", "bash", "artifact_read"]);
+const EXECUTABLE_GRAPH_TOOLS = new Set([
+  "read",
+  "read_image",
+  "write",
+  "edit",
+  "bash",
+  "artifact_read",
+]);
 const CONTROL_PLANE_TOOLS = new Set(["plan_graph", "task_run"]);
 const DEFAULT_OPENAI_BASE_URL = "https://api.openai.com/v1";
 const DEFAULT_ANTHROPIC_BASE_URL = "https://api.anthropic.com/v1";
@@ -392,6 +401,23 @@ function buildCoreToolSpecs() {
         },
       },
     },
+    {
+      type: "function",
+      function: {
+        name: "read_image",
+        description: getReadImageToolDescription(),
+        parameters: {
+          type: "object",
+          properties: {
+            path: {
+              type: "string",
+              description: "Workspace-relative path to a png, jpeg, gif, or webp image.",
+            },
+          },
+          required: ["path"],
+        },
+      },
+    },
     {
       type: "function",
       function: {

package/src/code/providers/anthropicMessagesTransport.js

@@ -1,6 +1,12 @@
 "use strict";
 
 const { assertTransport } = require("./transportContract");
+const {
+  extractVisionPayload,
+  stripVisionBase64,
+  visionSummaryText,
+  toAnthropicImageBlock,
+} = require("./visionBlocks");
 
 /**
  * Anthropic Messages API transport adapter.
@@ -70,11 +76,32 @@ function createAnthropicMessagesTransport(deps = {}) {
       }));
     },
     appendToolResult({ collected, call, toolResult }) {
+      const vision = extractVisionPayload(toolResult);
+      const isError = Boolean(!toolResult || toolResult.ok === false);
+      if (vision) {
+        const textPayload = stripVisionBase64(toolResult);
+        collected.push({
+          type: "tool_result",
+          tool_use_id: String(call.source.id || ""),
+          content: [
+            {
+              type: "text",
+              text: clipText(
+                `${visionSummaryText(vision, toolResult)}\n${toJsonString(textPayload)}`,
+                12000,
+              ),
+            },
+            toAnthropicImageBlock(vision),
+          ],
+          is_error: isError,
+        });
+        return;
+      }
       collected.push({
         type: "tool_result",
         tool_use_id: String(call.source.id || ""),
         content: clipText(toJsonString(toolResult), 12000),
-        is_error: Boolean(!toolResult || toolResult.ok === false),
+        is_error: isError,
       });
     },
     flushToolResults({ messages, collected }) {

package/src/code/providers/index.js

@@ -5,4 +5,5 @@ module.exports = {
   ...require("./openaiChatTransport"),
   ...require("./anthropicMessagesTransport"),
   ...require("./modelsCatalog"),
+  ...require("./visionBlocks"),
 };

package/src/code/providers/openaiChatTransport.js

@@ -2,6 +2,12 @@
 
 const { randomUUID } = require("crypto");
 const { assertTransport } = require("./transportContract");
+const {
+  extractVisionPayload,
+  stripVisionBase64,
+  visionSummaryText,
+  toOpenAiImagePart,
+} = require("./visionBlocks");
 
 /**
  * OpenAI-compatible chat-completions transport adapter.
@@ -82,11 +88,23 @@ function createOpenAiChatTransport(deps = {}) {
       }));
     },
     appendToolResult({ messages, call, toolResult }) {
+      const vision = extractVisionPayload(toolResult);
+      const payload = vision ? stripVisionBase64(toolResult) : toolResult;
       messages.push({
         role: "tool",
         tool_call_id: call.source.id,
-        content: clipText(toJsonString(toolResult), 12000),
+        content: clipText(toJsonString(payload), 12000),
       });
+      if (vision) {
+        const imagePart = toOpenAiImagePart(vision);
+        messages.push({
+          role: "user",
+          content: [
+            { type: "text", text: visionSummaryText(vision, toolResult) },
+            imagePart,
+          ],
+        });
+      }
     },
   };
 

package/src/code/providers/visionBlocks.js

@@ -0,0 +1,110 @@
+"use strict";
+
+/**
+ * Helpers for expanding read_image tool results into provider vision blocks.
+ */
+
+function extractVisionPayload(toolResult = null) {
+  if (!toolResult || typeof toolResult !== "object") return null;
+  const base64 = String(toolResult.base64 || "").trim();
+  const mediaType = String(toolResult.mediaType || "").trim().toLowerCase();
+  if (!base64 || !mediaType.startsWith("image/")) return null;
+  if (toolResult.ok === false) return null;
+  return {
+    path: String(toolResult.path || "").trim(),
+    mediaType,
+    bytes: Number.isFinite(toolResult.bytes) ? toolResult.bytes : null,
+    base64,
+    artifactId: String(toolResult.artifactId || "").trim(),
+  };
+}
+
+function isVisionToolResult(toolResult = null) {
+  return Boolean(extractVisionPayload(toolResult));
+}
+
+function stripVisionBase64(value) {
+  if (Array.isArray(value)) {
+    return value.map((item) => stripVisionBase64(item));
+  }
+  if (!value || typeof value !== "object") return value;
+  const out = {};
+  for (const [key, entry] of Object.entries(value)) {
+    if (key === "base64") continue;
+    out[key] = stripVisionBase64(entry);
+  }
+  return out;
+}
+
+function visionSummaryText(vision = null, toolResult = null) {
+  const pathText = (vision && vision.path) || (toolResult && toolResult.path) || "image";
+  const mediaType = (vision && vision.mediaType) || (toolResult && toolResult.mediaType) || "image/*";
+  const bytes = (vision && vision.bytes) != null
+    ? vision.bytes
+    : (toolResult && toolResult.bytes);
+  const parts = [
+    `Image loaded for vision: ${pathText}`,
+    `mediaType=${mediaType}`,
+  ];
+  if (Number.isFinite(bytes)) parts.push(`bytes=${bytes}`);
+  if (vision && vision.artifactId) parts.push(`artifactId=${vision.artifactId}`);
+  parts.push("Visual content is attached for this model call only; call read_image again later if needed.");
+  return parts.join(" | ");
+}
+
+function toAnthropicImageBlock(vision = null) {
+  if (!vision) return null;
+  return {
+    type: "image",
+    source: {
+      type: "base64",
+      media_type: vision.mediaType,
+      data: vision.base64,
+    },
+  };
+}
+
+function toOpenAiImagePart(vision = null) {
+  if (!vision) return null;
+  return {
+    type: "image_url",
+    image_url: {
+      url: `data:${vision.mediaType};base64,${vision.base64}`,
+    },
+  };
+}
+
+function degradeVisionContent(content) {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return content;
+  const texts = [];
+  for (const block of content) {
+    if (!block || typeof block !== "object") continue;
+    const type = String(block.type || "").trim().toLowerCase();
+    if (type === "text" && block.text) {
+      texts.push(String(block.text));
+      continue;
+    }
+    if (type === "image" || type === "image_url") {
+      const pathHint = block.path
+        || (block.source && block.source.path)
+        || "";
+      texts.push(pathHint ? `[image: ${pathHint}]` : "[image]");
+      continue;
+    }
+    if (type === "tool_result" && Array.isArray(block.content)) {
+      texts.push(degradeVisionContent(block.content));
+    }
+  }
+  return texts.filter(Boolean).join("\n") || "[multimodal content]";
+}
+
+module.exports = {
+  extractVisionPayload,
+  isVisionToolResult,
+  stripVisionBase64,
+  visionSummaryText,
+  toAnthropicImageBlock,
+  toOpenAiImagePart,
+  degradeVisionContent,
+};

package/src/code/tools/readImage.js

@@ -0,0 +1,110 @@
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+const { resolveWorkspacePath } = require("./common");
+
+const MAX_IMAGE_BYTES = 5 * 1024 * 1024;
+
+const EXT_MEDIA = Object.freeze({
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".webp": "image/webp",
+});
+
+function sniffMediaType(buffer = Buffer.alloc(0)) {
+  if (!Buffer.isBuffer(buffer) || buffer.length < 12) return "";
+  if (buffer[0] === 0x89 && buffer[1] === 0x50 && buffer[2] === 0x4e && buffer[3] === 0x47) {
+    return "image/png";
+  }
+  if (buffer[0] === 0xff && buffer[1] === 0xd8 && buffer[2] === 0xff) {
+    return "image/jpeg";
+  }
+  if (buffer[0] === 0x47 && buffer[1] === 0x49 && buffer[2] === 0x46) {
+    return "image/gif";
+  }
+  if (
+    buffer[0] === 0x52 && buffer[1] === 0x49 && buffer[2] === 0x46 && buffer[3] === 0x46
+    && buffer[8] === 0x57 && buffer[9] === 0x45 && buffer[10] === 0x42 && buffer[11] === 0x50
+  ) {
+    return "image/webp";
+  }
+  return "";
+}
+
+function mediaTypeFromPath(filePath = "") {
+  const ext = path.extname(String(filePath || "")).toLowerCase();
+  return EXT_MEDIA[ext] || "";
+}
+
+function runReadImageTool(input = {}, options = {}) {
+  try {
+    const filePath = String(input.path || input.file || "").trim();
+    if (!filePath) {
+      return { ok: false, error: "path is required" };
+    }
+    const { workspaceRoot, resolved } = resolveWorkspacePath(
+      options.workspaceRoot,
+      filePath,
+      options.cwd,
+    );
+    const stat = fs.statSync(resolved);
+    if (!stat.isFile()) {
+      return { ok: false, error: `not a file: ${resolved}` };
+    }
+    if (stat.size > MAX_IMAGE_BYTES) {
+      return {
+        ok: false,
+        error: `image too large (${stat.size} bytes); max ${MAX_IMAGE_BYTES} bytes — compress or resize first`,
+        path: resolved,
+        bytes: stat.size,
+      };
+    }
+
+    const buffer = fs.readFileSync(resolved);
+    const sniffed = sniffMediaType(buffer);
+    const fromExt = mediaTypeFromPath(resolved);
+    const mediaType = sniffed || fromExt;
+    if (!mediaType) {
+      return {
+        ok: false,
+        error: "unsupported image type (use png, jpeg, gif, or webp)",
+        path: resolved,
+        bytes: buffer.length,
+      };
+    }
+    if (fromExt && sniffed && fromExt !== sniffed) {
+      return {
+        ok: false,
+        error: `image type mismatch: extension suggests ${fromExt}, bytes are ${sniffed}`,
+        path: resolved,
+        bytes: buffer.length,
+      };
+    }
+
+    return {
+      ok: true,
+      kind: "image",
+      workspaceRoot,
+      path: resolved,
+      mediaType,
+      bytes: buffer.length,
+      base64: buffer.toString("base64"),
+    };
+  } catch (err) {
+    return {
+      ok: false,
+      error: err && err.message ? err.message : "read_image failed",
+    };
+  }
+}
+
+module.exports = {
+  MAX_IMAGE_BYTES,
+  EXT_MEDIA,
+  sniffMediaType,
+  mediaTypeFromPath,
+  runReadImageTool,
+};

package/src/ui/format/index.js

@@ -38,10 +38,14 @@ const STATUS_INDICATORS = {
 // Keep this list in sync with the keys handled by buildMergedToolSummaryText.
 const TOOL_LABELS = {
   read: "Reading file",
+  read_image: "Reading image",
   write: "Writing file",
   edit: "Editing file",
   bash: "Running command",
   artifact_read: "Reading artifact",
+  plan_graph: "Updating plan",
+  task_run: "Managing task",
+  ask_user: "Asking user",
 };
 
 const ANSI_PATTERN = /\x1B\[[0-9;?]*[ -/]*[@-~]/g;
@@ -283,7 +287,15 @@ function messageContentText(message = {}) {
   if (Array.isArray(content)) {
     return content.map((part) => {
       if (typeof part === "string") return part;
-      if (part && typeof part === "object" && part.text != null) return String(part.text);
+      if (!part || typeof part !== "object") return "";
+      const type = String(part.type || "").trim().toLowerCase();
+      if (type === "image" || type === "image_url") {
+        const name = part.fileName
+          || (part.path ? require("path").basename(String(part.path)) : "")
+          || "image";
+        return `[image: ${name}]`;
+      }
+      if (part.text != null) return String(part.text);
       return "";
     }).join("");
   }
@@ -296,15 +308,47 @@ function toolMessagePreview(message = {}) {
   try {
     const parsed = JSON.parse(raw);
     if (parsed && typeof parsed === "object") {
+      if (parsed.kind === "image" || parsed.base64 || parsed.mediaType) {
+        const name = require("path").basename(String(parsed.path || parsed.fileName || "image"));
+        return parsed.preview || `[image: ${name}]`;
+      }
       if (parsed.preview) return String(parsed.preview);
       if (parsed.artifactId) return `artifact:${parsed.artifactId}`;
+      if (parsed.base64) {
+        const clone = { ...parsed };
+        delete clone.base64;
+        return JSON.stringify(clone);
+      }
     }
   } catch {
     // plain tool text
   }
+  if (/data:image\/[a-zA-Z+]+;base64,/.test(raw) || /"base64"\s*:/.test(raw)) {
+    return "[image]";
+  }
   return raw;
 }
 
+/**
+ * Collapse attached-image prompt prefixes / base64 blobs for TUI log display.
+ */
+function redactUserMessageForLog(text = "") {
+  let out = String(text || "");
+  out = out.replace(
+    /\[Attached images[^\]]*\]\s*(?:-\s*.+\n?)*/gi,
+    (block) => {
+      const paths = [...block.matchAll(/^\s*-\s*(.+)$/gm)].map((m) => String(m[1] || "").trim());
+      if (paths.length === 0) return "[image]";
+      return paths
+        .map((p) => `[image: ${require("path").basename(p)}]`)
+        .join(" ");
+    },
+  );
+  out = out.replace(/data:image\/[a-zA-Z+]+;base64,[A-Za-z0-9+/=\s]+/g, "[image]");
+  out = out.replace(/"base64"\s*:\s*"[^"]*"/g, '"base64":"[redacted]"');
+  return out.replace(/\n{3,}/g, "\n\n").trim();
+}
+
 /**
  * Convert persisted nlMessages into ucode TUI log rows for resume/history.
  * Applies the shared ANSI markdown renderer so restored assistant text matches
@@ -349,7 +393,7 @@ function buildUcodeSessionLogEntries(messages = [], options = {}) {
     if (!message || typeof message !== "object") continue;
     const role = String(message.role || "").trim().toLowerCase();
     if (role === "user") {
-      const text = messageContentText(message);
+      const text = redactUserMessageForLog(messageContentText(message));
       if (!text.trim()) continue;
       const lines = text.split(/\r?\n/);
       lines.forEach((line, index) => {
@@ -671,6 +715,12 @@ function normalizeToolLogDetail(tool = "", args = {}, payload = {}) {
     return shortenPathDetail(pathText);
   }
 
+  if (name === "read_image") {
+    const pathText = String(argObj.path || resObj.path || resObj.fileName || "").trim();
+    const base = pathText ? require("path").basename(pathText) : "image";
+    return `[image: ${base}]`;
+  }
+
   if (name === "artifact_read") {
     const artifactId = String(argObj.artifactId || argObj.id || resObj.artifactId || "").trim();
     const rangeBits = [];
@@ -1295,6 +1345,9 @@ module.exports = {
   normalizeModelLabel,
   normalizeToolLogDetail,
   normalizeToolMergeEntry,
+  messageContentText,
+  toolMessagePreview,
+  redactUserMessageForLog,
   parseActiveAgentsFromBusStatus,
   planAgentsFooter,
   planProjectsRail,

package/src/ui/ink/MultilineInput.js

@@ -25,6 +25,11 @@
  *                               component (e.g. completion popup) can
  *                               handle them. Plain editing keys still work.
  *   placeholder (string)        rendered in gray when value is empty
+ *   onPasteText(filtered)       optional. Called for non-empty paste/insert
+ *                               chunks before insertText. May return:
+ *                                 string — insert that text instead
+ *                                 { text } — insert text (may be "")
+ *                                 null/undefined — fall back to filtered text
  *
  * Newlines: Enter submits. Use Alt+Enter (delivered as meta+Return) or end the
  * line with `\` (the legacy continuation trick) to insert a literal newline.
@@ -32,7 +37,8 @@
  * plain Enter, so it would silently submit.
  *
  * Bracketed paste arrives as a multi-byte `input` chunk in useInput; we route
- * it through insertText, so multi-line paste already works without extra code.
+ * it through insertText (or onPasteText), so multi-line paste already works
+ * without extra code.
  */
 
 const fmt = require("../format");
@@ -167,6 +173,7 @@ function createMultilineInput({ React, ink }) {
     // the IME composition window pops up at the visible (inverse) cursor
     // instead of at the bottom of the screen.
     linesBelowInput = 0,
+    onPasteText = null,
   }) {
     // Cursor is owned by this component. preferredCol tracks the visual
     // column we want to keep when bouncing across lines of different widths
@@ -392,7 +399,36 @@ function createMultilineInput({ React, ink }) {
       // Plain character / paste. Filter control bytes.
       if (input && !key.ctrl && !key.meta) {
         const filtered = input.replace(/[\x00-\x08\x0b-\x0c\x0e-\x1f\x7f]/g, "");
-        if (filtered) insertText(filtered);
+        // Binary clipboard paste can strip to empty — still notify parent so
+        // it can try macOS PNGf clipboard ingest.
+        if (!filtered) {
+          if (typeof onPasteText === "function") {
+            try { onPasteText(""); } catch { /* ignore */ }
+          }
+          return;
+        }
+        if (typeof onPasteText === "function" && (filtered.length > 1 || filtered.includes("\n"))) {
+          let rewritten;
+          try {
+            rewritten = onPasteText(filtered);
+          } catch {
+            rewritten = filtered;
+          }
+          if (rewritten == null) {
+            insertText(filtered);
+            return;
+          }
+          if (typeof rewritten === "string") {
+            if (rewritten) insertText(rewritten);
+            return;
+          }
+          if (rewritten && typeof rewritten === "object") {
+            const nextText = rewritten.text == null ? filtered : String(rewritten.text);
+            if (nextText) insertText(nextText);
+            return;
+          }
+        }
+        insertText(filtered);
       }
     }, { isActive: interactive });