expect(getToolProperties(tool).timeoutMs).toMatchObject({ type: "integer", minimum: 1 });

});

it("advertises shared poll duration as a positive integer", () => {

const tool = createMessageTool();

expect(getToolProperties(tool).pollDurationHours).toMatchObject({

type: "integer",

minimum: 1,

});

});

it.each([-1, 1.5, "fast"])(

"rejects invalid timeoutMs value %s before dispatch",

async (timeoutMs) => {

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

import { resolveSessionAgentId } from "../agent-scope.js";

import { listAllChannelSupportedActions, listChannelSupportedActions } from "../channel-tools.js";

import { channelTargetSchema, channelTargetsSchema, stringEnum } from "../schema/typebox.js";

import {

channelTargetSchema,

channelTargetsSchema,

optionalPositiveIntegerSchema,

stringEnum,

} from "../schema/typebox.js";

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

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

import { gatewayCallOptionSchemaProperties } from "./gateway-schema.js";

case "stringArray":

props[name] = Type.Optional(Type.Array(Type.String()));

break;

case "number":

props[name] = Type.Optional(Type.Number());

case "positiveInteger":

props[name] = optionalPositiveIntegerSchema();

break;

case "boolean":

props[name] = Type.Optional(Type.Boolean());

expect(call?.ctx?.params?.threadId).toBe("42");

});

it.each([0, -1, 1.5, "1.5", "soon"])(

"rejects invalid pollDurationHours value %s",

async (pollDurationHours) => {

await expect(

runPollAction({

cfg: pollerConfig,

actionParams: {

channel: "poller",

target: "poller:123",

pollQuestion: "Lunch?",

pollOption: ["Pizza", "Sushi"],

pollDurationHours,

},

}),

).rejects.toThrow(/pollDurationHours must be a positive integer/i);

},

);

it("passes inbound event kind to poll execution", async () => {

const call = await runPollAction({

cfg: pollerConfig,

import { resolveSessionAgentId } from "../../agents/agent-scope.js";

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

import {

readNumberParam,

readPositiveIntegerParam,

readStringArrayParam,

readStringParam,

} from "../../agents/tools/common.js";

throw new Error("pollOption requires at least two values");

}

const allowMultiselect = readBooleanParam(params, "pollMulti") ?? false;

const durationHours = readNumberParam(params, "pollDurationHours", {

integer: true,

strict: true,

const durationHours = readPositiveIntegerParam(params, "pollDurationHours", {

message: "pollDurationHours must be a positive integer",

});

return {

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

import { normalizeLowercaseStringOrEmpty } from "./shared/string-coerce.js";

type PollCreationParamKind = "string" | "stringArray" | "number" | "boolean";

type PollCreationParamKind = "string" | "stringArray" | "positiveInteger" | "boolean";

type PollCreationParamDef = {

kind: PollCreationParamKind;

const SHARED_POLL_CREATION_PARAM_DEFS = {

pollQuestion: { kind: "string" },

pollOption: { kind: "stringArray" },

pollDurationHours: { kind: "number" },

pollDurationHours: { kind: "positiveInteger" },

pollMulti: { kind: "boolean" },

} satisfies Record<string, PollCreationParamDef>;

return true;

}

}

if (def.kind === "number") {

if (def.kind === "positiveInteger") {

// Treat zero-valued numeric defaults as unset, but preserve any non-zero

// numeric value as explicit poll intent so invalid durations still hit

// the poll-only validation path.