@syengup/friday-channel-next 0.1.36 → 0.1.37

package/src/history/normalize-message.test.ts

@@ -1,8 +1,5 @@
 import { describe, it, expect } from "vitest";
-import {
-  normalizeHistoryMessage,
-  normalizeHistoryMessages,
-} from "./normalize-message.js";
+import { normalizeHistoryMessage, normalizeHistoryMessages } from "./normalize-message.js";
 
 function meta(id?: string, seq = 1, extra: Record<string, unknown> = {}) {
   return { __openclaw: { ...(id ? { id } : {}), seq, recordTimestampMs: 1700000000000, ...extra } };
@@ -124,7 +121,7 @@ describe("normalizeHistoryMessage", () => {
     expect(out?.toolResult?.images).toBeUndefined();
   });
 
-  it("keeps image blocks on non-canvas toolResults", () => {
+  it("keeps image blocks on image-producing (image_generation) toolResults", () => {
     const out = normalizeHistoryMessage(
       {
         role: "toolResult",
@@ -138,11 +135,34 @@ describe("normalizeHistoryMessage", () => {
     expect(out?.toolResult?.images).toEqual([{ mimeType: "image/png", data: "REALIMG" }]);
   });
 
+  it("drops inline image blocks on read toolResults (agent visual input, not an attachment)", () => {
+    // The `read` tool returns the file it fed to the model as an inline base64
+    // image so the agent can "see" it. That is NOT a user-facing attachment —
+    // surfacing it spawned phantom corrupt image bubbles on history rebuild for
+    // turns where the agent only LOOKED at a file and sent nothing.
+    const out = normalizeHistoryMessage(
+      {
+        role: "toolResult",
+        toolCallId: "tc-read",
+        toolName: "read",
+        content: [
+          { type: "text", text: "Read image file [image/jpeg]" },
+          { type: "image", mimeType: "image/jpeg", data: "AGENTVISUALINPUT" },
+        ],
+        ...meta("entry-read", 7),
+      },
+      0,
+    );
+    expect(out?.toolResult?.images).toBeUndefined();
+    expect(out?.toolResult?.text).toBe("Read image file [image/jpeg]");
+  });
+
   it("strips MEDIA: lines from text into mediaPaths", () => {
     const out = normalizeHistoryMessage(
       {
         role: "assistant",
-        content: "Here is the serene landscape 🌅\nMEDIA:/Users/me/.openclaw/media/tool-image-generation/x.png",
+        content:
+          "Here is the serene landscape 🌅\nMEDIA:/Users/me/.openclaw/media/tool-image-generation/x.png",
         ...meta("a1", 1),
       },
       0,
@@ -158,13 +178,20 @@ describe("normalizeHistoryMessage", () => {
     );
     expect(out?.text).toBe("two files");
     expect(out?.mediaPaths).toEqual(["/a/x.png", "/a/y.mp4"]);
-    const plain = normalizeHistoryMessage({ role: "user", content: "no media here", ...meta("u", 1) }, 0);
+    const plain = normalizeHistoryMessage(
+      { role: "user", content: "no media here", ...meta("u", 1) },
+      0,
+    );
     expect(plain?.mediaPaths).toBeUndefined();
   });
 
   it("flags compaction records via __openclaw.kind", () => {
     const out = normalizeHistoryMessage(
-      { role: "system", content: [{ type: "text", text: "Compaction" }], ...meta("c1", 9, { kind: "compaction" }) },
+      {
+        role: "system",
+        content: [{ type: "text", text: "Compaction" }],
+        ...meta("c1", 9, { kind: "compaction" }),
+      },
       0,
     );
     expect(out?.kind).toBe("compaction");

package/src/history/normalize-message.ts

@@ -104,6 +104,17 @@ function splitMediaLines(text: string): { text: string; paths: string[] } {
   return { text: cleaned, paths };
 }
 
+/**
+ * Tools whose `toolResult` carries a user-facing PRODUCED image, which stays a
+ * chat attachment. Every OTHER tool's inline image block is the agent's visual
+ * INPUT — a file the `read` tool fed to the model, a `canvas` snapshot, a
+ * browser screenshot — and must NOT surface as an attachment on history rebuild
+ * (it spawns phantom, often-corrupt bubbles for turns where the agent never
+ * sent a file). Keep this a whitelist so any new image-CONSUMING tool is safe by
+ * default; add new image-PRODUCING tools here explicitly.
+ */
+const IMAGE_PRODUCING_TOOLS = new Set(["image_generation"]);
+
 const MEDIA_MARKER_RE = /\[media attached:\s*([^\]]+)\]/gi;
 
 /** Pull `[media attached: <url>]` markers out of free text into image refs. */
@@ -219,10 +230,7 @@ function normalizeRole(raw: unknown): FridayHistoryRole {
  * Normalize one raw transcript message. `index` is the position in the returned
  * batch, used only to synthesize a stable-ish id when upstream omits one.
  */
-export function normalizeHistoryMessage(
-  raw: unknown,
-  index: number,
-): FridayHistoryMessage | null {
+export function normalizeHistoryMessage(raw: unknown, index: number): FridayHistoryMessage | null {
   const record = asRecord(raw);
   if (!record) return null;
 
@@ -254,14 +262,18 @@ export function normalizeHistoryMessage(
   if (role === "toolResult") {
     const split = splitMediaLines(parsed.text);
     const toolName = readString(record.toolName);
-    // Canvas snapshots come back as base64 image blocks on the `canvas` tool result so the *agent*
-    // can "see" the rendered page — they must never surface as chat attachments on history rebuild.
-    // The streaming deliver path already drops the temp-file form (see isCanvasSnapshotMediaPath in
-    // http/handlers/messages.ts); this is the transcript-rebuild counterpart. The canvas tool has no
-    // other image-returning action, so all images on a canvas result are snapshots.
-    const isCanvasResult = toolName === "canvas";
-    const images = isCanvasResult ? [] : parsed.images;
-    const mediaPaths = isCanvasResult ? [] : split.paths;
+    // Inline image blocks on a toolResult are almost always the agent's visual
+    // INPUT — a file the `read` tool fed to the model, a `canvas` snapshot (so the
+    // agent can "see" the rendered page), a browser screenshot — NOT a user-facing
+    // attachment. Surfacing them spawns phantom, often-corrupt attachment bubbles on
+    // history rebuild for turns where the agent never sent a file. Only tools that
+    // PRODUCE a user-facing image keep their blocks. (This was a `canvas`-only
+    // blacklist, which still leaked `read`/screenshot images.) The streaming deliver
+    // path drops the canvas temp-file form separately (isCanvasSnapshotMediaPath in
+    // http/handlers/messages.ts); this is the transcript-rebuild counterpart.
+    const keepInlineImages = toolName ? IMAGE_PRODUCING_TOOLS.has(toolName) : false;
+    const images = keepInlineImages ? parsed.images : [];
+    const mediaPaths = toolName === "canvas" ? [] : split.paths;
     const toolResult: FridayHistoryToolResult = {
       ...(readString(record.toolCallId) ? { toolCallId: readString(record.toolCallId) } : {}),
       ...(toolName ? { toolName } : {}),

package/src/history/read-transcript.ts

@@ -40,10 +40,7 @@ function resolveEntry(store: Record<string, unknown>, sessionKey: string): unkno
   return undefined;
 }
 
-export function resolveTranscriptPath(
-  entry: unknown,
-  storePath: string,
-): string | undefined {
+export function resolveTranscriptPath(entry: unknown, storePath: string): string | undefined {
   const sessionFile = entryString(entry, "sessionFile");
   if (sessionFile) {
     return path.isAbsolute(sessionFile)

package/src/http/handlers/agent-config.test.ts

@@ -123,7 +123,9 @@ describe("handleAgentConfig", () => {
   });
 
   it("PUT sets the model on an existing entry", async () => {
-    const config: Record<string, unknown> = { agents: { list: [{ id: "main", model: "old/model" }] } };
+    const config: Record<string, unknown> = {
+      agents: { list: [{ id: "main", model: "old/model" }] },
+    };
     setRuntimes(config);
     const res = new MockRes();
     await handleAgentConfig(makeReq(AUTH, "PUT", { model: "openai/gpt-5" }), res as any, "main");
@@ -133,7 +135,9 @@ describe("handleAgentConfig", () => {
   });
 
   it("PUT model:null deletes the field so it inherits defaults", async () => {
-    const config: Record<string, unknown> = { agents: { list: [{ id: "main", model: "old/model" }] } };
+    const config: Record<string, unknown> = {
+      agents: { list: [{ id: "main", model: "old/model" }] },
+    };
     setRuntimes(config);
     const res = new MockRes();
     await handleAgentConfig(makeReq(AUTH, "PUT", { model: null }), res as any, "main");
@@ -197,7 +201,10 @@ describe("handleAgentConfig", () => {
       setRuntimes({ agents: { list: [{ id: "main" }] } }, workspace);
       const res = new MockRes();
       await handleAgentConfig(makeReq(AUTH), res as any, "main");
-      expect(JSON.parse(res.body).availableSkills.map((s: { id: string }) => s.id)).toEqual(["deep-research", "verify"]);
+      expect(JSON.parse(res.body).availableSkills.map((s: { id: string }) => s.id)).toEqual([
+        "deep-research",
+        "verify",
+      ]);
     } finally {
       fs.rmSync(workspace, { recursive: true, force: true });
     }

package/src/http/handlers/agent-config.ts

@@ -60,7 +60,9 @@ function readString(value: unknown): string | undefined {
 
 function readStringArray(value: unknown): string[] | undefined {
   if (!Array.isArray(value)) return undefined;
-  const out = value.filter((v): v is string => typeof v === "string" && v.trim().length > 0).map((v) => v.trim());
+  const out = value
+    .filter((v): v is string => typeof v === "string" && v.trim().length > 0)
+    .map((v) => v.trim());
   return out;
 }
 
@@ -81,7 +83,9 @@ function readToolsConfig(value: unknown): AgentToolsConfig | undefined {
 
 /** Locate the configured `agents.list[]` entry whose normalized id matches `agentId`. */
 function findAgentEntry(cfg: unknown, agentId: string): Record<string, unknown> | undefined {
-  const agents = (cfg as Record<string, unknown> | undefined)?.agents as Record<string, unknown> | undefined;
+  const agents = (cfg as Record<string, unknown> | undefined)?.agents as
+    | Record<string, unknown>
+    | undefined;
   const list = agents?.list as Array<Record<string, unknown>> | undefined;
   if (!Array.isArray(list)) return undefined;
   return list.find((a) => a && typeof a === "object" && normalizeAgentId(a.id) === agentId);
@@ -108,7 +112,11 @@ function buildConfigView(agentId: string): AgentConfigView {
 /** A field present in the body: `undefined` = not sent (keep), `null` = clear, else new value. */
 type Patch<T> = { sent: boolean; clear: boolean; value?: T };
 
-function readPatch<T>(body: Record<string, unknown>, key: string, coerce: (raw: unknown) => T | undefined): Patch<T> {
+function readPatch<T>(
+  body: Record<string, unknown>,
+  key: string,
+  coerce: (raw: unknown) => T | undefined,
+): Patch<T> {
   if (!(key in body)) return { sent: false, clear: false };
   const raw = body[key];
   if (raw === null) return { sent: true, clear: true };
@@ -117,7 +125,7 @@ function readPatch<T>(body: Record<string, unknown>, key: string, coerce: (raw:
   return { sent: true, clear: false, value };
 }
 
-function coerceModel(raw: unknown): unknown | undefined {
+function coerceModel(raw: unknown): unknown {
   if (typeof raw === "string") return raw.trim() || undefined;
   if (raw && typeof raw === "object") {
     const primary = readString((raw as Record<string, unknown>).primary);
@@ -134,7 +142,7 @@ function coerceTools(raw: unknown): AgentToolsConfig | undefined {
 
 /** Skills: array (incl. empty = disable all) only; non-arrays are rejected upstream. */
 function coerceSkills(raw: unknown): string[] | undefined {
-  return Array.isArray(raw) ? readStringArray(raw) ?? [] : undefined;
+  return Array.isArray(raw) ? (readStringArray(raw) ?? []) : undefined;
 }
 
 // --- handler -----------------------------------------------------------------
@@ -167,10 +175,14 @@ export async function handleAgentConfig(
   const skills = readPatch(body, "skills", coerceSkills);
 
   if ("skills" in body && body.skills !== null && !Array.isArray(body.skills)) {
-    return json(res, 400, { error: "skills must be an array of skill ids, [] to disable all, or null to inherit defaults" });
+    return json(res, 400, {
+      error: "skills must be an array of skill ids, [] to disable all, or null to inherit defaults",
+    });
   }
   if (!model.sent && !thinkingDefault.sent && !tools.sent && !skills.sent) {
-    return json(res, 400, { error: "No editable fields provided (model, thinkingDefault, tools, skills)" });
+    return json(res, 400, {
+      error: "No editable fields provided (model, thinkingDefault, tools, skills)",
+    });
   }
 
   const upgrade = getUpgradeRuntime();
@@ -184,7 +196,9 @@ export async function handleAgentConfig(
         const draft = draftRaw as Record<string, unknown>;
         const agents = (draft.agents ??= {}) as Record<string, unknown>;
         const list = (agents.list ??= []) as Array<Record<string, unknown>>;
-        let entry = list.find((a) => a && typeof a === "object" && normalizeAgentId(a.id) === agentId);
+        let entry = list.find(
+          (a) => a && typeof a === "object" && normalizeAgentId(a.id) === agentId,
+        );
         if (!entry) {
           // Implicit agent (e.g. "main") with no list entry yet — create a bare one.
           // Never set `default: true`: that would change default-agent resolution.

package/src/http/handlers/agents-list.test.ts

@@ -141,11 +141,7 @@ describe("handleAgentsList", () => {
   it("defaults to the first entry when none is marked default and dedups ids", async () => {
     setConfig({
       agents: {
-        list: [
-          { id: "alpha" },
-          { id: "alpha", name: "dup" },
-          { id: "beta" },
-        ],
+        list: [{ id: "alpha" }, { id: "alpha", name: "dup" }, { id: "beta" }],
       },
     });
     const res = new MockRes();

package/src/http/handlers/cancel.test.ts

@@ -19,8 +19,14 @@ class MockRes extends EventEmitter {
   }
 }
 
-function mockReq(method: string, headers: Record<string, string> = {}): PassThrough & { method: string; headers: Record<string, string> } {
-  const stream = new PassThrough() as unknown as PassThrough & { method: string; headers: Record<string, string> };
+function mockReq(
+  method: string,
+  headers: Record<string, string> = {},
+): PassThrough & { method: string; headers: Record<string, string> } {
+  const stream = new PassThrough() as unknown as PassThrough & {
+    method: string;
+    headers: Record<string, string>;
+  };
   stream.method = method;
   stream.headers = headers;
   return stream;
@@ -63,7 +69,10 @@ describe("handleCancel", () => {
     req.end(JSON.stringify({ sessionKey: "sk-1" }));
     await p;
     expect((res as unknown as MockRes).statusCode).toBe(200);
-    expect(JSON.parse((res as unknown as MockRes).body)).toMatchObject({ ok: true, sessionKey: "sk-1" });
+    expect(JSON.parse((res as unknown as MockRes).body)).toMatchObject({
+      ok: true,
+      sessionKey: "sk-1",
+    });
   });
 
   it("untracks run by runId fallback under Vitest (abort skipped)", async () => {

package/src/http/handlers/cancel.ts

@@ -25,14 +25,16 @@ export async function handleCancel(req: IncomingMessage, res: ServerResponse): P
   // back-compat fallback for older apps — resolve it to a sessionKey via the run route.
   const sessionKey =
     (typeof body?.sessionKey === "string" ? body.sessionKey.trim() : "") ||
-    (runId ? getRunRoute(runId)?.sessionKey?.trim() ?? "" : "");
+    (runId ? (getRunRoute(runId)?.sessionKey?.trim() ?? "") : "");
   if (!sessionKey && !runId) {
     res.statusCode = 400;
     res.setHeader("Content-Type", "application/json");
     res.end(JSON.stringify({ error: "Missing sessionKey or runId" }));
     return true;
   }
-  const result = sessionKey ? await abortRunForSessionKey(sessionKey) : { aborted: false, drained: false };
+  const result = sessionKey
+    ? await abortRunForSessionKey(sessionKey)
+    : { aborted: false, drained: false };
   if (runId) sseEmitter.untrackRun(runId);
   res.statusCode = 200;
   res.setHeader("Content-Type", "application/json");

package/src/http/handlers/device-approve.test.ts

@@ -28,8 +28,14 @@ class MockRes extends EventEmitter {
   }
 }
 
-function mockReq(method: string, headers: Record<string, string> = {}): PassThrough & { method: string; headers: Record<string, string> } {
-  const stream = new PassThrough() as unknown as PassThrough & { method: string; headers: Record<string, string> };
+function mockReq(
+  method: string,
+  headers: Record<string, string> = {},
+): PassThrough & { method: string; headers: Record<string, string> } {
+  const stream = new PassThrough() as unknown as PassThrough & {
+    method: string;
+    headers: Record<string, string>;
+  };
   stream.method = method;
   stream.headers = headers;
   return stream;
@@ -92,7 +98,10 @@ describe("handleDeviceApprove", () => {
   });
 
   it("returns 404 when listDevicePairing returns data without matching device", async () => {
-    mockList.mockResolvedValueOnce({ pending: [{ requestId: "x", deviceId: "UNMATCHED" }], paired: [] });
+    mockList.mockResolvedValueOnce({
+      pending: [{ requestId: "x", deviceId: "UNMATCHED" }],
+      paired: [],
+    });
 
     const req = mockReq("POST", { authorization: "Bearer test-token" });
     const res = new MockRes() as unknown as ServerResponse;

package/src/http/handlers/device-approve.ts

@@ -67,21 +67,25 @@ export async function handleDeviceApprove(
     if (pairedDevice) {
       res.statusCode = 200;
       res.setHeader("Content-Type", "application/json");
-      res.end(JSON.stringify({
-        ok: true,
-        deviceId: normalizedDeviceId,
-        alreadyApproved: true,
-        approvedAtMs: (pairedDevice as any).approvedAtMs,
-      }));
+      res.end(
+        JSON.stringify({
+          ok: true,
+          deviceId: normalizedDeviceId,
+          alreadyApproved: true,
+          approvedAtMs: (pairedDevice as any).approvedAtMs,
+        }),
+      );
       return true;
     }
 
     res.statusCode = 404;
     res.setHeader("Content-Type", "application/json");
-    res.end(JSON.stringify({
-      error: "No pending device found for this deviceId",
-      deviceId: normalizedDeviceId,
-    }));
+    res.end(
+      JSON.stringify({
+        error: "No pending device found for this deviceId",
+        deviceId: normalizedDeviceId,
+      }),
+    );
     return true;
   }
 
@@ -95,10 +99,12 @@ export async function handleDeviceApprove(
     log.error(`approveDevicePairing failed: ${err instanceof Error ? err.message : String(err)}`);
     res.statusCode = 502;
     res.setHeader("Content-Type", "application/json");
-    res.end(JSON.stringify({
-      error: "Device approval failed",
-      detail: err instanceof Error ? err.message : "Unknown error",
-    }));
+    res.end(
+      JSON.stringify({
+        error: "Device approval failed",
+        detail: err instanceof Error ? err.message : "Unknown error",
+      }),
+    );
     return true;
   }
 
@@ -112,17 +118,23 @@ export async function handleDeviceApprove(
   if (approved.status === "forbidden") {
     res.statusCode = 403;
     res.setHeader("Content-Type", "application/json");
-    res.end(JSON.stringify({ error: `Device approval forbidden: ${(approved as any).reason ?? "unknown"}` }));
+    res.end(
+      JSON.stringify({
+        error: `Device approval forbidden: ${(approved as any).reason ?? "unknown"}`,
+      }),
+    );
     return true;
   }
 
   res.statusCode = 200;
   res.setHeader("Content-Type", "application/json");
-  res.end(JSON.stringify({
-    ok: true,
-    deviceId: normalizedDeviceId,
-    requestId: approved.requestId,
-    approvedAtMs: (approved as any).device?.approvedAtMs,
-  }));
+  res.end(
+    JSON.stringify({
+      ok: true,
+      deviceId: normalizedDeviceId,
+      requestId: approved.requestId,
+      approvedAtMs: (approved as any).device?.approvedAtMs,
+    }),
+  );
   return true;
 }

package/src/http/handlers/files-download.ts

@@ -63,7 +63,10 @@ function tryDecodeURIComponent(segment: string): string | null {
  */
 function contentDispositionInline(filename: string): string {
   const base =
-    path.basename(filename).replace(/[\r\n"]/g, "_").replace(/\\/g, "_") || "file";
+    path
+      .basename(filename)
+      .replace(/[\r\n"]/g, "_")
+      .replace(/\\/g, "_") || "file";
   const ascii = /^[\x20-\x7E]*$/.test(base) ? base : "file";
   return `inline; filename="${ascii}"; filename*=UTF-8''${encodeURIComponent(base)}`;
 }
@@ -82,9 +85,7 @@ function sendBuffer(
   const disposition = contentDispositionInline(filename);
   const rangeRaw = req.headers.range;
   const range =
-    typeof rangeRaw === "string" && /^bytes=/i.test(rangeRaw.trim())
-      ? rangeRaw.trim()
-      : undefined;
+    typeof rangeRaw === "string" && /^bytes=/i.test(rangeRaw.trim()) ? rangeRaw.trim() : undefined;
 
   res.setHeader("Accept-Ranges", "bytes");
   res.setHeader("Cache-Control", "private, max-age=3600");
@@ -110,7 +111,7 @@ function sendBuffer(
   let end = total - 1;
 
   if (m[1] === "" && m[2] !== "") {
-    const suffixLen = parseInt(m[2]!, 10);
+    const suffixLen = parseInt(m[2], 10);
     if (!Number.isFinite(suffixLen) || suffixLen <= 0) {
       res.statusCode = 200;
       res.setHeader("Content-Length", String(total));
@@ -120,11 +121,11 @@ function sendBuffer(
     start = Math.max(0, total - suffixLen);
     end = total - 1;
   } else if (m[1] !== "" && m[2] === "") {
-    start = parseInt(m[1]!, 10);
+    start = parseInt(m[1], 10);
     end = total - 1;
   } else if (m[1] !== "" && m[2] !== "") {
-    start = parseInt(m[1]!, 10);
-    end = parseInt(m[2]!, 10);
+    start = parseInt(m[1], 10);
+    end = parseInt(m[2], 10);
   }
 
   if (!Number.isFinite(start) || !Number.isFinite(end) || start > end || start >= total) {
@@ -190,7 +191,13 @@ export async function handleFilesDownload(
     // 1.2 Plugin-root attachments/ (survives gateway restarts; basename = URL token)
     const fromAttachments = readAttachmentFileFromDisk(fileToken);
     if (fromAttachments) {
-      sendBuffer(req, res, fromAttachments.buffer, fromAttachments.mimeType, fromAttachments.filename);
+      sendBuffer(
+        req,
+        res,
+        fromAttachments.buffer,
+        fromAttachments.mimeType,
+        fromAttachments.filename,
+      );
       return true;
     }
 
@@ -211,10 +218,7 @@ export async function handleFilesDownload(
     // fileId may include an extension (e.g. "uuid.png") — strip it to get the base id
     const baseId = fileToken.replace(/\.[^.]+$/, "");
     const mediaDir = path.join(os.homedir(), ".openclaw", "media", "inbound");
-    const candidates = [
-      path.join(mediaDir, baseId),
-      path.join(mediaDir, fileToken),
-    ];
+    const candidates = [path.join(mediaDir, baseId), path.join(mediaDir, fileToken)];
 
     for (const filePath of candidates) {
       if (fs.existsSync(filePath)) {

package/src/http/handlers/files.test.ts

@@ -28,7 +28,11 @@ afterEach(() => {
 
 describe("attachment original filename survives a gateway restart", () => {
   it("stores under a uuid token but recovers the original filename from disk", () => {
-    const stored = storeFile(Buffer.from("%PDF-1.4 fake"), "Quarterly Report.pdf", "application/pdf");
+    const stored = storeFile(
+      Buffer.from("%PDF-1.4 fake"),
+      "Quarterly Report.pdf",
+      "application/pdf",
+    );
     expect(stored.urlToken).not.toBe("Quarterly Report.pdf");
 
     const disk = readAttachmentFileFromDisk(stored.urlToken);
@@ -57,7 +61,9 @@ describe("attachment original filename survives a gateway restart", () => {
     const stored = storeFile(Buffer.from("x"), "doc.docx", "application/octet-stream");
     clearFileIndexForTest();
 
-    const publicUrl = fridayFilesPublicUrl(`/friday-next/files/${encodeURIComponent(stored.urlToken)}`);
+    const publicUrl = fridayFilesPublicUrl(
+      `/friday-next/files/${encodeURIComponent(stored.urlToken)}`,
+    );
     expect(publicUrl).toBe(`/friday-next/files/${encodeURIComponent(stored.urlToken)}`);
   });
 

package/src/http/handlers/files.ts

@@ -25,7 +25,9 @@ export function setAttachmentsDirForTest(dir: string | null): void {
 /** Resolve `<historyDir>/../attachments`, mirroring the offline-queue layout. */
 function resolveAttachmentsDir(): string {
   try {
-    const cfg = resolveFridayNextConfig(getHostOpenClawConfigSnapshot(getFridayNextRuntime().config));
+    const cfg = resolveFridayNextConfig(
+      getHostOpenClawConfigSnapshot(getFridayNextRuntime().config),
+    );
     return path.join(path.dirname(cfg.historyDir), "attachments");
   } catch {
     return path.join(os.homedir(), ".openclaw", "friday-next", "attachments");
@@ -112,7 +114,11 @@ function writeAttachmentMetaSidecar(urlToken: string, filename: string, mimeType
  * is unrecoverable. We stash it here (keyed by the inbound basename, reusing the sidecar
  * scheme but inside our own attachments dir) at send time, while we still know it.
  */
-export function rememberInboundMediaName(inboundPath: string, filename: string, mimeType: string): void {
+export function rememberInboundMediaName(
+  inboundPath: string,
+  filename: string,
+  mimeType: string,
+): void {
   const key = path.basename(inboundPath);
   const name = filename.trim();
   if (!key || !name) return;
@@ -191,7 +197,10 @@ export function normalizeAgentMediaPath(raw: string): string {
   return s;
 }
 
-function copyLocalFileToAttachments(sourcePath: string, originalFilename?: string): StoredFile | null {
+function copyLocalFileToAttachments(
+  sourcePath: string,
+  originalFilename?: string,
+): StoredFile | null {
   const resolvedPath = normalizeAgentMediaPath(sourcePath);
   const diskBasename = path.basename(resolvedPath);
   // Prefer the caller-supplied original name (recovered from an inbound sidecar); fall
@@ -211,7 +220,9 @@ function copyLocalFileToAttachments(sourcePath: string, originalFilename?: strin
       // Fallback to read+write so attachment persistence still works.
       const raw = fs.readFileSync(resolvedPath);
       fs.writeFileSync(storedPath, raw);
-      logger.warn(`copyLocalFileToAttachments copy fallback used for "${resolvedPath}": ${String(copyErr)}`);
+      logger.warn(
+        `copyLocalFileToAttachments copy fallback used for "${resolvedPath}": ${String(copyErr)}`,
+      );
     }
     const stat = fs.statSync(storedPath);
     const mimeType = guessMimeType(filename);
@@ -246,7 +257,7 @@ export function storeFile(buffer: Buffer, filename: string, mimeType: string): S
   try {
     fs.writeFileSync(storedPath, buffer);
   } catch (err) {
-    throw new Error(`Failed to store file: ${String(err)}`);
+    throw new Error(`Failed to store file: ${String(err)}`, { cause: err });
   }
 
   const file: StoredFile = {
@@ -314,7 +325,11 @@ export function getExternalFileSourceByUrlToken(token: string): string | undefin
 /**
  * Read a file as a Buffer with its MIME type (by id or urlToken).
  */
-export function readFile(id: string): { buffer: Buffer | null; mimeType: string; filename?: string } {
+export function readFile(id: string): {
+  buffer: Buffer | null;
+  mimeType: string;
+  filename?: string;
+} {
   const file = resolveStoredFile(id);
   if (!file) return { buffer: null, mimeType: "application/octet-stream" };
   try {
@@ -400,7 +415,6 @@ export function resolveMediaAttachment(localPath: string): ResolvedAttachment |
   };
 }
 
-
 /**
  * Guess MIME type from filename extension.
  */