const defaultLoadOptions = mockCallArg(webMedia.loadWebMedia, 0, "loadWebMedia", 1);

expect(defaultLoadUrl).toBe("http://198.18.0.153/reference.png");

expect(requireRecord(defaultLoadOptions, "loadWebMedia options").ssrfPolicy).toBeUndefined();

expect(requireRecord(defaultLoadOptions, "loadWebMedia options").readIdleTimeoutMs).toBe(

120_000,

);

const tool = requireImageGenerateTool(

createImageGenerateTool({

expect(requireRecord(configuredLoadOptions, "loadWebMedia options").ssrfPolicy).toEqual({

allowRfc2544BenchmarkRange: true,

});

expect(requireRecord(configuredLoadOptions, "loadWebMedia options").readIdleTimeoutMs).toBe(

120_000,

);

expect(mockCallArg(generateImage, 1, "generateImage").ssrfPolicy).toEqual({

allowRfc2544BenchmarkRange: true,

});

hasGenerationToolAvailability,

normalizeMediaReferenceInputs,

readGenerationTimeoutMs,

REMOTE_MEDIA_READ_IDLE_TIMEOUT_MS,

resolveRemoteMediaSsrfPolicy,

resolveCapabilityModelConfigForTool,

resolveGenerateAction,

maxBytes: params.maxBytes,

localRoots,

ssrfPolicy: params.ssrfPolicy,

...(isHttpUrl ? { readIdleTimeoutMs: REMOTE_MEDIA_READ_IDLE_TIMEOUT_MS } : {}),

});

if (media.kind !== "image") {

throw new ToolInputError(`Unsupported media type: ${media.kind}`);

});

});

it("passes the shared remote read idle timeout when loading remote image references", async () => {

const fetch = vi.fn(

async () =>

new Response(

JSON.stringify({ content: "ok", base_resp: { status_code: 0, status_msg: "" } }),

),

);

global.fetch = withFetchPreconnect(fetch);

vi.stubEnv("MINIMAX_API_KEY", "minimax-test");

const loadWebMedia = vi.fn(async () => ({

buffer: Buffer.from(ONE_PIXEL_PNG_B64, "base64"),

contentType: "image/png",

kind: "image" as const,

}));

installImageUnderstandingProviderDeps([minimaxProvider, moonshotProvider], {

loadImageWebMediaRuntime: async () => ({

loadWebMedia,

optimizeImageBufferForWebMedia: async ({ buffer, contentType, fileName }) => ({

buffer,

contentType: contentType ?? "image/png",

kind: "image",

fileName,

}),

}),

});

await withTempAgentDir(async (agentDir) => {

const tool = createRequiredImageTool({

config: createMinimaxImageConfig(),

agentDir,

});

await expectImageToolExecOk(tool, "https://example.test/reference.png");

expect(loadWebMedia).toHaveBeenCalledTimes(1);

const [, options] = fetchCallAt(loadWebMedia, 0);

expect((options as { readIdleTimeoutMs?: number }).readIdleTimeoutMs).toBe(120_000);

});

});

it("sandboxes image paths like the read tool", async () => {

await withTempSandboxState(async ({ agentDir, sandboxRoot }) => {

await fs.writeFile(path.join(sandboxRoot, "img.png"), "fake", "utf8");

import {

applyImageModelConfigDefaults,

buildTextToolResult,

REMOTE_MEDIA_READ_IDLE_TIMEOUT_MS,

resolveMediaToolInboundRoots,

resolveMediaToolLocalRoots,

resolveRemoteMediaSsrfPolicy,

localRoots?: readonly string[] | "any";

inboundRoots?: readonly string[];

ssrfPolicy?: ReturnType<typeof resolveRemoteMediaSsrfPolicy>;

readIdleTimeoutMs?: number;

};

type ImageWebMediaRuntime = {

localRoots: mediaLocalRoots,

inboundRoots: mediaInboundRoots,

ssrfPolicy: remoteMediaSsrfPolicy,

...(isHttpUrl ? { readIdleTimeoutMs: REMOTE_MEDIA_READ_IDLE_TIMEOUT_MS } : {}),

imageCompression,

});

if (media.kind !== "image") {

runId: string;

};

export const REMOTE_MEDIA_READ_IDLE_TIMEOUT_MS = 120_000;

export function applyImageModelConfigDefaults(

cfg: OpenClawConfig | undefined,

imageModelConfig: ImageModelConfig,

import {

applyImageModelConfigDefaults,

buildTextToolResult,

REMOTE_MEDIA_READ_IDLE_TIMEOUT_MS,

resolveModelFromRegistry,

resolveMediaToolLocalRoots,

resolveModelRuntimeApiKey,

const DEFAULT_MAX_PDFS = 10;

const DEFAULT_MAX_BYTES_MB = 10;

const DEFAULT_MAX_PAGES = 20;

const PDF_REMOTE_READ_IDLE_TIMEOUT_MS = 120_000;

const PDF_MIN_TEXT_CHARS = 200;

const PDF_MAX_PIXELS = 4_000_000;

: await loadWebMediaRaw(resolvedPathInfo.resolved, {

maxBytes,

localRoots,

...(isHttpUrl ? { readIdleTimeoutMs: PDF_REMOTE_READ_IDLE_TIMEOUT_MS } : {}),

...(isHttpUrl ? { readIdleTimeoutMs: REMOTE_MEDIA_READ_IDLE_TIMEOUT_MS } : {}),

ssrfPolicy: remoteMediaSsrfPolicy,

});

expect(call.inputImages?.[1]?.role).toBe("last_frame");

});

it("passes direct remote reference URLs to the provider without local media loading", async () => {

mockVideoPluginProvider({

imageToVideo: { enabled: true, maxInputImages: 1 },

});

const loadWebMedia = vi.spyOn(webMedia, "loadWebMedia").mockResolvedValue({

kind: "image",

buffer: Buffer.from("image"),

contentType: "image/png",

});

const generateSpy = mockSavedVideoResult();

const tool = createVideoPluginTool();

await tool.execute("call-1", {

prompt: "lobster",

image: "https://example.test/reference.png",

});

expect(loadWebMedia).not.toHaveBeenCalled();

const call = firstMockCallArg(generateSpy) as {

inputImages?: Array<{ url?: string }>;

};

expect(call.inputImages).toEqual([{ url: "https://example.test/reference.png" }]);

});

it("passes web_fetch SSRF policy when loading reference assets", async () => {

mockVideoPluginProvider({

imageToVideo: { enabled: true, maxInputImages: 1 },