fix: persist generated reply media before delivery

Author: steipete

CHANGELOG.md

@@ -195,6 +195,7 @@ Docs: https://docs.openclaw.ai
 - Windows/restart: clean up stale gateway listeners before Windows self-restart and treat listener and argv probe failures as inconclusive, so scheduled-task relaunch no longer falls into an `EADDRINUSE` retry loop. (#60480) Thanks @arifahmedjoy.
 - Plugins: suppress trust-warning noise during non-activating snapshot and CLI metadata loads. (#61427) Thanks @gumadeiras.
 - Agents/video generation: accept `agents.defaults.videoGenerationModel` in strict config validation and `openclaw config set/get`, so gateways using `video_generate` no longer fail to boot after enabling a video model.
+- Discord/image generation: persist volatile workspace-generated media into durable outbound media before final reply delivery so generated image replies stop failing with missing local workspace paths.
 
 ## 2026.4.2
 

src/auto-reply/reply/reply-media-paths.test.ts

@@ -2,16 +2,22 @@ import path from "node:path";
 import { beforeEach, describe, expect, it, vi } from "vitest";
 
 const ensureSandboxWorkspaceForSession = vi.hoisted(() => vi.fn());
+const saveMediaSource = vi.hoisted(() => vi.fn());
 
 vi.mock("../../agents/sandbox.js", () => ({
   ensureSandboxWorkspaceForSession,
 }));
 
+vi.mock("../../media/store.js", () => ({
+  saveMediaSource,
+}));
+
 import { createReplyMediaPathNormalizer } from "./reply-media-paths.js";
 
 describe("createReplyMediaPathNormalizer", () => {
   beforeEach(() => {
     ensureSandboxWorkspaceForSession.mockReset().mockResolvedValue(null);
+    saveMediaSource.mockReset();
   });
 
   it("resolves workspace-relative media against the agent workspace", async () => {
@@ -74,6 +80,7 @@ describe("createReplyMediaPathNormalizer", () => {
       mediaUrl: "/Users/peter/.openclaw/media/inbound/photo.png",
       mediaUrls: ["/Users/peter/.openclaw/media/inbound/photo.png"],
     });
+    expect(saveMediaSource).not.toHaveBeenCalled();
   });
 
   it("keeps sandbox media strict when workspaceOnly is enabled", async () => {
@@ -93,4 +100,31 @@ describe("createReplyMediaPathNormalizer", () => {
       }),
     ).rejects.toThrow(/sandbox root|outside|escapes/i);
   });
+
+  it("persists volatile agent-state media from the workspace into host outbound media", async () => {
+    saveMediaSource.mockResolvedValue({
+      path: "/Users/peter/.openclaw/media/outbound/persisted.png",
+    });
+    const normalize = createReplyMediaPathNormalizer({
+      cfg: {},
+      sessionKey: "session-key",
+      workspaceDir: "/Users/peter/.openclaw/workspace",
+    });
+
+    const result = await normalize({
+      mediaUrls: [
+        "/Users/peter/.openclaw/workspace/.openclaw/media/tool-image-generation/generated.png",
+      ],
+    });
+
+    expect(saveMediaSource).toHaveBeenCalledWith(
+      "/Users/peter/.openclaw/workspace/.openclaw/media/tool-image-generation/generated.png",
+      undefined,
+      "outbound",
+    );
+    expect(result).toMatchObject({
+      mediaUrl: "/Users/peter/.openclaw/media/outbound/persisted.png",
+      mediaUrls: ["/Users/peter/.openclaw/media/outbound/persisted.png"],
+    });
+  });
 });

src/auto-reply/reply/reply-media-paths.ts

@@ -1,17 +1,26 @@
+import path from "node:path";
 import { resolveSendableOutboundReplyParts } from "openclaw/plugin-sdk/reply-payload";
 import { resolveSessionAgentId } from "../../agents/agent-scope.js";
 import { resolvePathFromInput } from "../../agents/path-policy.js";
 import { assertMediaNotDataUrl, resolveSandboxedMediaSource } from "../../agents/sandbox-paths.js";
 import { ensureSandboxWorkspaceForSession } from "../../agents/sandbox.js";
 import { resolveEffectiveToolFsWorkspaceOnly } from "../../agents/tool-fs-policy.js";
 import type { OpenClawConfig } from "../../config/config.js";
+import { logVerbose } from "../../globals.js";
+import { saveMediaSource } from "../../media/store.js";
 import type { ReplyPayload } from "../types.js";
 
 const HTTP_URL_RE = /^https?:\/\//i;
 const FILE_URL_RE = /^file:\/\//i;
 const WINDOWS_DRIVE_RE = /^[a-zA-Z]:[\\/]/;
 const SCHEME_RE = /^[a-zA-Z][a-zA-Z0-9+.-]*:/;
 const HAS_FILE_EXT_RE = /\.\w{1,10}$/;
+const AGENT_STATE_MEDIA_DIRNAME = path.join(".openclaw", "media");
+
+function isPathInside(root: string, candidate: string): boolean {
+  const relative = path.relative(path.resolve(root), path.resolve(candidate));
+  return relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative));
+}
 
 function isLikelyLocalMediaSource(media: string): boolean {
   return (
@@ -44,6 +53,7 @@ export function createReplyMediaPathNormalizer(params: {
     agentId,
   });
   let sandboxRootPromise: Promise<string | undefined> | undefined;
+  const persistedMediaBySource = new Map<string, Promise<string>>();
 
   const resolveSandboxRoot = async (): Promise<string | undefined> => {
     if (!sandboxRootPromise) {
@@ -56,6 +66,36 @@ export function createReplyMediaPathNormalizer(params: {
     return await sandboxRootPromise;
   };
 
+  const persistVolatileAgentMedia = async (media: string): Promise<string> => {
+    if (!path.isAbsolute(media)) {
+      return media;
+    }
+    const sandboxRoot = await resolveSandboxRoot();
+    const volatileRoots = [params.workspaceDir, sandboxRoot]
+      .filter((root): root is string => Boolean(root))
+      .map((root) => path.join(path.resolve(root), AGENT_STATE_MEDIA_DIRNAME));
+    if (!volatileRoots.some((root) => isPathInside(root, media))) {
+      return media;
+    }
+    const cached = persistedMediaBySource.get(media);
+    if (cached) {
+      return await cached;
+    }
+    const persistPromise = saveMediaSource(media, undefined, "outbound")
+      .then((saved) => saved.path)
+      .catch((err) => {
+        persistedMediaBySource.delete(media);
+        throw err;
+      });
+    persistedMediaBySource.set(media, persistPromise);
+    try {
+      return await persistPromise;
+    } catch (err) {
+      logVerbose(`failed to persist volatile reply media ${media}: ${String(err)}`);
+      return media;
+    }
+  };
+
   const normalizeMediaSource = async (raw: string): Promise<string> => {
     const media = raw.trim();
     if (!media) {
@@ -100,7 +140,7 @@ export function createReplyMediaPathNormalizer(params: {
     const normalizedMedia: string[] = [];
     const seen = new Set<string>();
     for (const media of mediaList) {
-      const normalized = await normalizeMediaSource(media);
+      const normalized = await persistVolatileAgentMedia(await normalizeMediaSource(media));
       if (!normalized || seen.has(normalized)) {
         continue;
       }