import type { OpenClawPluginApi } from "openclaw/plugin-sdk/plugin-runtime";

import {

jsonResult,

readNumberParam,

readPositiveIntegerParam,

readStringParam,

} from "openclaw/plugin-sdk/provider-web-search";

import { Type } from "typebox";

description: '"basic" (default) or "advanced" (for JS-heavy pages).',

}),

chunks_per_source: Type.Optional(

Type.Number({

Type.Integer({

description: "Chunks per URL (1-5, requires query).",

minimum: 1,

maximum: 5,

}

const query = readStringParam(rawParams, "query") || undefined;

const extractDepth = readStringParam(rawParams, "extract_depth") || undefined;

const chunksPerSource = readNumberParam(rawParams, "chunks_per_source", {

integer: true,

const chunksPerSource = readPositiveIntegerParam(rawParams, "chunks_per_source", {

max: 5,

message: "chunks_per_source must be an integer from 1 to 5.",

});

if (chunksPerSource !== undefined && !query) {

throw new Error("tavily_extract requires query when chunks_per_source is set.");

import type { OpenClawPluginApi } from "openclaw/plugin-sdk/plugin-runtime";

import {

jsonResult,

readNumberParam,

readPositiveIntegerParam,

readStringParam,

} from "openclaw/plugin-sdk/provider-web-search";

import { Type } from "typebox";

description: 'Search topic: "general" (default), "news", or "finance".',

}),

max_results: Type.Optional(

Type.Number({

Type.Integer({

description: "Number of results to return (1-20).",

minimum: 1,

maximum: 20,

const query = readStringParam(rawParams, "query", { required: true });

const searchDepth = readStringParam(rawParams, "search_depth") || undefined;

const topic = readStringParam(rawParams, "topic") || undefined;

const maxResults = readNumberParam(rawParams, "max_results", { integer: true });

const maxResults = readPositiveIntegerParam(rawParams, "max_results", {

max: 20,

message: "max_results must be an integer from 1 to 20.",

});

const includeAnswer = rawParams.include_answer === true;

const timeRange = readStringParam(rawParams, "time_range") || undefined;

const includeDomains = Array.isArray(rawParams.include_domains)

expect(runTavilyExtract).not.toHaveBeenCalled();

});

it("rejects fractional and out-of-range integer options before Tavily calls", async () => {

const searchTool = createTavilySearchTool(fakeApi());

await expect(

searchTool.execute("search-call", {

query: "openclaw",

max_results: 5.5,

}),

).rejects.toThrow("max_results must be an integer from 1 to 20.");

await expect(

searchTool.execute("search-call", {

query: "openclaw",

max_results: 21,

}),

).rejects.toThrow("max_results must be an integer from 1 to 20.");

const extractTool = createTavilyExtractTool(fakeApi());

await expect(

extractTool.execute("extract-call", {

urls: ["https://example.com"],

query: "pricing",

chunks_per_source: 2.5,

}),

).rejects.toThrow("chunks_per_source must be an integer from 1 to 5.");

await expect(

extractTool.execute("extract-call", {

urls: ["https://example.com"],

query: "pricing",

chunks_per_source: 6,

}),

).rejects.toThrow("chunks_per_source must be an integer from 1 to 5.");

expect(runTavilySearch).not.toHaveBeenCalled();

expect(runTavilyExtract).not.toHaveBeenCalled();

});

it("reads plugin web search config and prefers it over env defaults", () => {

vi.stubEnv("TAVILY_API_KEY", "env-key");

vi.stubEnv("TAVILY_BASE_URL", "https://env.tavily.test");

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

}),

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

expect(() =>

readPositiveIntegerParam({ maxResults: 21 }, "maxResults", {

max: 20,

message: "maxResults must be an integer from 1 to 20",

}),

).toThrow("maxResults must be an integer from 1 to 20");

});

});

key: string,

options: {

message?: string;

max?: number;

} = {},

): number | undefined {

const value = readNumberParam(params, key, {

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

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

}

if (value !== undefined && options.max !== undefined && value > options.max) {

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

}

return value;

}

export {

jsonResult,

readNumberParam,

readPositiveIntegerParam,

readStringArrayParam,

readStringParam,

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