import { describe, expect, it } from "vitest";

import {

createActionGate,

readPositiveIntegerParam,

readNumberParam,

readReactionParams,

readStringOrNumberParam,

}),

).toBeUndefined();

});

it("throws for invalid present positive integer params", () => {

expect(readPositiveIntegerParam({ timeoutMs: "42" }, "timeoutMs")).toBe(42);

expect(() => readPositiveIntegerParam({ timeoutMs: "42.5" }, "timeoutMs")).toThrow(

"timeoutMs must be a positive integer",

);

expect(() =>

readPositiveIntegerParam({ timeoutMs: 0 }, "timeoutMs", {

message: "timeoutMs must be a positive integer in milliseconds.",

}),

).toThrow("timeoutMs must be a positive integer in milliseconds.");

});

});

describe("snake_case aliases", () => {

return integer ? Math.trunc(value) : value;

}

export function readPositiveIntegerParam(

params: Record<string, unknown>,

key: string,

options: {

message?: string;

} = {},

): number | undefined {

const value = readNumberParam(params, key, {

positiveInteger: true,

strict: true,

});

if (value === undefined && readParamRaw(params, key) !== undefined) {

throw new ToolInputError(options.message ?? `${key} must be a positive integer`);

}

return value;

}

export function readStringArrayParam(

params: Record<string, unknown>,

key: string,

}),

),

timeoutMs: Type.Optional(

Type.Number({

Type.Integer({

description: "Provider timeout ms (300000 tends to be a safe amount).",

minimum: 1,

}),

import type { OpenClawConfig } from "../../config/types.openclaw.js";

import type { SsrFPolicy } from "../../infra/net/ssrf.js";

import type { Model } from "../../llm/types.js";

import { resolveChannelInboundAttachmentRootsForChannel } from "../../media/channel-inbound-roots.js";

import { normalizeInboundPathRoots } from "../../media/inbound-path-policy.js";

import {

findCapabilityProviderById,

resolveCapabilityModelRefForProviders,

} from "../../media-generation/capability-model-ref.js";

import { resolveChannelInboundAttachmentRootsForChannel } from "../../media/channel-inbound-roots.js";

import { normalizeInboundPathRoots } from "../../media/inbound-path-policy.js";

import { getDefaultLocalRoots } from "../../media/local-media-access.js";

import { readSnakeCaseParamRaw } from "../../param-key.js";

import { loadCapabilityManifestSnapshot } from "../../plugins/capability-provider-runtime.js";

import { normalizeProviderId } from "../provider-id.js";

import {

ToolInputError,

readNumberParam,

readPositiveIntegerParam,

readStringArrayParam,

readStringParam,

} from "./common.js";

}

export function readGenerationTimeoutMs(args: Record<string, unknown>): number | undefined {

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

integer: true,

strict: true,

return readPositiveIntegerParam(args, "timeoutMs", {

message: "timeoutMs must be a positive integer in milliseconds.",

});

if (timeoutMs === undefined) {

return undefined;

}

if (timeoutMs <= 0) {

throw new ToolInputError("timeoutMs must be a positive integer in milliseconds.");

}

return timeoutMs;

}

export function resolveRemoteMediaSsrfPolicy(

expect(requireRecord(result.details, "TTS result details").timeoutMs).toBe(12_345);

});

it("rejects fractional timeout before calling speech generation", async () => {

textToSpeechSpy.mockResolvedValue({

success: true,

audioPath: "/tmp/reply.opus",

provider: "test",

voiceCompatible: true,

});

const tool = createTtsTool();

await expect(tool.execute("call-1", { text: "hello", timeoutMs: 12_345.5 })).rejects.toThrow(

"timeoutMs must be a positive integer in milliseconds.",

);

expect(textToSpeechSpy).not.toHaveBeenCalled();

});

it("passes the active agent id to speech generation", async () => {

textToSpeechSpy.mockResolvedValue({

success: true,

import { textToSpeech } from "../../tts/tts.js";

import type { GatewayMessageChannel } from "../../utils/message-channel.js";

import type { AnyAgentTool } from "./common.js";

import { ToolInputError, readNumberParam, readStringParam } from "./common.js";

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

const TtsToolSchema = Type.Object({

text: Type.String({ description: "Text to speak." }),

channel: Type.Optional(Type.String({ description: "Channel id; output-format hint." })),

timeoutMs: Type.Optional(

Type.Number({

Type.Integer({

description: "Provider timeout ms.",

minimum: 1,

}),

),

});

function readTtsTimeoutMs(args: Record<string, unknown>): number | undefined {

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

integer: true,

strict: true,

return readPositiveIntegerParam(args, "timeoutMs", {

message: "timeoutMs must be a positive integer in milliseconds.",

});

if (timeoutMs === undefined) {

return undefined;

}

if (timeoutMs <= 0) {

throw new ToolInputError("timeoutMs must be a positive integer in milliseconds.");

}

return timeoutMs;

}

/**

}),

),

timeoutMs: Type.Optional(

Type.Number({

Type.Integer({

description: "Provider timeout ms.",

minimum: 1,

}),