import type { ImageSanitizationLimits } from "../image-sanitization.js";

import type { AgentToolResult } from "../runtime/index.js";

import { sanitizeToolResultImages } from "../tool-images.js";

import { readPositiveIntegerParam } from "./common.js";

import type { GatewayCallOptions } from "./gateway.js";

import { callGatewayTool } from "./gateway.js";

import { resolveNode, resolveNodeId } from "./nodes-utils.js";

]);

export type NodeMediaAction = "camera_snap" | "photos_latest" | "camera_clip" | "screen_record";

const MAX_RECORDING_DURATION_MS = 300_000;

type ExecuteNodeMediaActionParams = {

action: NodeMediaAction;

if (facing !== "front" && facing !== "back") {

throw new Error("invalid facing (front|back)");

}

const durationMs =

typeof params.durationMs === "number" && Number.isFinite(params.durationMs)

? params.durationMs

: typeof params.duration === "string"

? parseDurationMs(params.duration)

: 3000;

const durationMs = Math.min(

readPositiveIntegerParam(params, "durationMs") ??

(typeof params.duration === "string" ? parseDurationMs(params.duration) : 3000),

MAX_RECORDING_DURATION_MS,

);

const includeAudio = typeof params.includeAudio === "boolean" ? params.includeAudio : true;

const deviceId =

typeof params.deviceId === "string" && params.deviceId.trim()

const node = requireString(params, "node");

const nodeId = await resolveNodeId(gatewayOpts, node);

const durationMs = Math.min(

typeof params.durationMs === "number" && Number.isFinite(params.durationMs)

? params.durationMs

: typeof params.duration === "string"

? parseDurationMs(params.duration)

: 10_000,

300_000,

readPositiveIntegerParam(params, "durationMs") ??

(typeof params.duration === "string" ? parseDurationMs(params.duration) : 10_000),

MAX_RECORDING_DURATION_MS,

);

const fps = typeof params.fps === "number" && Number.isFinite(params.fps) ? params.fps : 10;

const screenIndex =

nodesCameraMocks.writeCameraPayloadToFile.mockClear();

});

it("caps durationMs schema at 300000", () => {

it("bounds durationMs schema to positive values capped at 300000", () => {

const tool = createNodesTool();

const schema = tool.parameters as {

properties?: {

durationMs?: {

minimum?: number;

maximum?: number;

type?: string;

};

};

};

expect(schema.properties?.durationMs?.type).toBe("integer");

expect(schema.properties?.durationMs?.minimum).toBe(1);

expect(schema.properties?.durationMs?.maximum).toBe(300_000);

});

expect(call[2].params?.durationMs).toBe(300_000);

});

it("clamps camera_clip durationMs argument to 300000 before gateway invoke", async () => {

gatewayMocks.callGatewayTool.mockResolvedValue({ payload: { ok: true } });

nodesCameraMocks.parseCameraClipPayload.mockReturnValue({

base64: "ZmFrZQ==",

format: "mp4",

durationMs: 300_000,

hasAudio: true,

});

nodesCameraMocks.writeCameraClipPayloadToFile.mockResolvedValue("/tmp/clip.mp4");

const tool = createNodesTool();

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

action: "camera_clip",

node: "macbook",

durationMs: 900_000,

});

const call = gatewayMocks.callGatewayTool.mock.calls[0] as

| [string, unknown, { params?: { durationMs?: unknown } }]

| undefined;

expect(call?.[0]).toBe("node.invoke");

expect(call?.[2].params?.durationMs).toBe(300_000);

});

it.each([

["screen_record", 0],

["screen_record", 1.5],

["camera_clip", -1],

["camera_clip", "1sec"],

])("rejects invalid %s durationMs value %s", async (action, durationMs) => {

const tool = createNodesTool();

await expect(

tool.execute("call-invalid-duration", {

action,

node: "macbook",

durationMs,

}),

).rejects.toThrow("durationMs must be a positive integer");

expect(gatewayMocks.callGatewayTool).not.toHaveBeenCalled();

});

it("rejects the removed run action", async () => {

const tool = createNodesTool();

deviceId: Type.Optional(Type.String()),

limit: Type.Optional(Type.Number()),

duration: Type.Optional(Type.String()),

durationMs: Type.Optional(Type.Number({ maximum: 300_000 })),

durationMs: Type.Optional(Type.Integer({ minimum: 1, maximum: 300_000 })),

includeAudio: Type.Optional(Type.Boolean()),

// screen_record

fps: Type.Optional(Type.Number()),