});

});

it("rejects fractional duration before calling the provider", async () => {

const generateVideo = vi.spyOn(videoGenerationRuntime, "generateVideo").mockResolvedValue({

provider: "google",

model: "veo-3.1-fast-generate-preview",

attempts: [],

ignoredOverrides: [],

videos: [

{

buffer: Buffer.from("video-bytes"),

mimeType: "video/mp4",

fileName: "lobster.mp4",

},

],

});

const tool = createVideoGenerateTool({

config: asConfig({

agents: {

defaults: {

videoGenerationModel: { primary: "google/veo-3.1-fast-generate-preview" },

},

},

}),

});

if (!tool) {

throw new Error("expected video_generate tool");

}

await expect(

tool.execute("call-1", {

prompt: "friendly lobster surfing",

durationSeconds: 5.5,

}),

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

expect(generateVideo).not.toHaveBeenCalled();

});

it("surfaces normalized video geometry from runtime metadata", async () => {

vi.spyOn(videoGenerationRuntime, "generateVideo").mockResolvedValue({

provider: "runway",

}),

),

durationSeconds: Type.Optional(

Type.Number({

Type.Integer({

description: "Target seconds; may round to nearest supported duration.",

minimum: 1,

}),

const aspectRatio = normalizeAspectRatio(readStringParam(args, "aspectRatio"));

const resolution = normalizeResolution(readStringParam(args, "resolution"));

const durationSeconds = readNumberParam(args, "durationSeconds", {

integer: true,

positiveInteger: true,

strict: true,

});

if (

durationSeconds === undefined &&

readSnakeCaseParamRaw(args, "durationSeconds") !== undefined

) {

throw new ToolInputError("durationSeconds must be a positive integer");

}

const audio = readBooleanToolParam(args, "audio");

const watermark = readBooleanToolParam(args, "watermark");

const timeoutMs = readGenerationTimeoutMs(args) ?? videoGenerationModelConfig.timeoutMs;