if (typeof value === "number") {

return normalizeModelPickerPage(value);

}

if (typeof value === "string" && value.trim()) {

const parsed = Number.parseInt(value, 10);

if (Number.isFinite(parsed)) {

if (typeof value === "string" && /^[+-]?\d+$/.test(value.trim())) {

const parsed = Number(value.trim());

if (Number.isSafeInteger(parsed)) {

return normalizeModelPickerPage(parsed);

}

}

if (typeof value !== "string" && typeof value !== "number") {

return undefined;

}

const parsed = Number.parseInt(String(value), 10);

if (!Number.isFinite(parsed) || parsed < 1) {

const raw = String(value).trim();

if (!/^[+]?\d+$/.test(raw)) {

return undefined;

}

return Math.floor(parsed);

const parsed = Number(raw);

if (!Number.isSafeInteger(parsed) || parsed < 1) {

return undefined;

}

return parsed;

}

function coerceString(value: unknown): string {

});

});

it("does not coerce partial numeric custom_id fields", () => {

expect(

parseDiscordModelPickerData({

cmd: "models",

act: "submit",

view: "models",

u: "42",

p: "openai",

pg: "3next",

mi: "7model",

}),

).toEqual({

command: "models",

action: "submit",

view: "models",

userId: "42",

provider: "openai",

page: 1,

});

});

it("rejects invalid command/action/view values", () => {

expect(

parseDiscordModelPickerData({

expect(parseMattermostModelPickerContext({ action: "select" })).toBeNull();

});

it("does not coerce partial page strings in signed picker contexts", () => {

expect(

parseMattermostModelPickerContext({

oc_model_picker: true,

action: "list",

ownerUserId: "user-1",

provider: "openai",

page: "2next",

}),

).toEqual({

action: "list",

ownerUserId: "user-1",

provider: "openai",

page: 1,

});

});

it("falls back to the routed agent default model when no override is stored", () => {

const testDir = fs.mkdtempSync(path.join(os.tmpdir(), "mm-model-picker-"));

try {

if (typeof value === "number" && Number.isFinite(value)) {

return value;

}

if (typeof value === "string") {

const parsed = Number.parseInt(value.trim(), 10);

if (Number.isFinite(parsed)) {

if (typeof value === "string" && /^[+-]?\d+$/.test(value.trim())) {

const parsed = Number(value.trim());

if (Number.isSafeInteger(parsed)) {

return parsed;

}

}

.option("--limit <n>", "Max results", "5")

.action(async (query, opts) => {

const vector = await embeddings.embed(normalizeRecallQuery(query, cfg.recallMaxChars));

const results = await db.search(vector, Number.parseInt(opts.limit, 10), 0.3);

const limit = parsePositiveIntegerOption(opts.limit, "--limit");

const results = await db.search(vector, limit, 0.3);

// Strip vectors for output

const output = results.map((r) => ({

id: r.entry.id,

}

query = query.where(filterCondition);

}

const limit = Number.parseInt(opts.limit, 10);

if (Number.isNaN(limit) || limit <= 0) {

throw new Error("Invalid limit: must be a positive integer");

}

const limit = parsePositiveIntegerOption(opts.limit, "--limit") ?? 10;

// Fetch all filtered rows first if we need to order them in memory

if (!opts.orderBy) {

};

}

function mockBotAdmin(features: number): void {

function mockBotAdmin(features: number | string): void {

hoisted.fetchWithSsrFGuard.mockResolvedValueOnce({

response: new Response(

JSON.stringify({

});

});

it("does not coerce partial bot feature strings", async () => {

mockBotAdmin("2response");

await expect(probeNextcloudTalkBotResponseFeature({ account: account() })).resolves.toEqual({

ok: false,

code: "missing_response_feature",

botId: "7",

botName: "OpenClaw",

message:

'Nextcloud Talk bot "OpenClaw" (7) is missing the response feature; outbound replies will fail. Run ./occ talk:bot:state --feature webhook --feature response --feature reaction 7 1 or reinstall the bot with --feature response.',

});

});

it("reports malformed bot admin JSON with a stable channel error", async () => {

hoisted.fetchWithSsrFGuard.mockResolvedValueOnce({

response: new Response("{ nope", {

if (typeof value === "number" && Number.isFinite(value)) {

return value;

}

if (typeof value === "string" && value.trim()) {

const parsed = Number.parseInt(value, 10);

return Number.isFinite(parsed) ? parsed : undefined;

if (typeof value === "string" && /^[+-]?\d+$/.test(value.trim())) {

const parsed = Number(value.trim());

return Number.isSafeInteger(parsed) ? parsed : undefined;

}

return undefined;

}

expect(release).toHaveBeenCalledTimes(1);

});

it("does not coerce partial room type strings", async () => {

fetchWithSsrFGuard.mockResolvedValue({

response: {

ok: true,

json: async () => ({

ocs: {

data: {

type: "1direct",

},

},

}),

},

release: vi.fn(async () => {}),

});

await expect(

resolveNextcloudTalkRoomKind({

account: {

accountId: "acct-partial",

baseUrl: "https://nc.example.com",

config: {

apiUser: "bot",

apiPassword: "secret",

},

} as never,

roomToken: "room-partial",

}),

).resolves.toBeUndefined();

});

it("reads the api password from a file and logs non-ok room info responses", async () => {

const release = vi.fn(async () => {});

const log = vi.fn();

if (typeof value === "number" && Number.isFinite(value)) {

return value;

}

if (typeof value === "string" && value.trim()) {

const parsed = Number.parseInt(value, 10);

return Number.isFinite(parsed) ? parsed : undefined;

if (typeof value === "string" && /^[+-]?\d+$/.test(value.trim())) {

const parsed = Number(value.trim());

return Number.isSafeInteger(parsed) ? parsed : undefined;

}

return undefined;

}

).toEqual({ kind: "ignored" });

});

it("ignores partial numeric media timestamps", () => {

const adapter = new TwilioStreamFrameAdapter();

expect(

adapter.parseInbound(

JSON.stringify({

event: "media",

media: { payload: "AAA=", timestamp: "20ms" },

}),

),

).toEqual({ kind: "media", payloadBase64: "AAA=" });

});

it("serializes outbound frames with the streamSid captured at start", () => {

const adapter = new TwilioStreamFrameAdapter();

adapter.parseInbound(