@brave/brave-search-mcp-server 2.0.80 → 2.0.82

package/dist/tools/llm_context/schemas/output.js

@@ -0,0 +1,66 @@
+import { z } from 'zod';
+/**
+ * Keep up to date with documentation:
+ * https://api-dashboard.search.brave.com/api-reference/summarizer/llm_context/get#responses
+ */
+const SnippetsSchema = z
+    .array(z.string())
+    .describe(`Extracted content chunks. Entries can mix plain prose, markdown-formatted text, and JSON-encoded structured data (e.g., extracted tables, schemas, or page metadata serialized as a string), so consumers should be prepared to detect and parse JSON strings rather than assuming every entry is plain text.`);
+const SourceMetadataSchema = z
+    .object({
+    title: z.string().optional().describe('The page title for the referenced URL.'),
+    hostname: z.string().optional().describe('The hostname extracted from the referenced URL.'),
+    age: z
+        .array(z.string())
+        .optional()
+        .describe('Discovery/age information for the source, typically formatted as human-readable, ISO date, and relative-age strings. May be an empty array when unavailable.'),
+    site_name: z
+        .string()
+        .optional()
+        .describe('Site name for the source (present when enable_source_metadata is true).'),
+    favicon: z
+        .string()
+        .optional()
+        .describe('Favicon URL for the source (present when enable_source_metadata is true).'),
+    thumbnail: z
+        .object({
+        src: z.string().optional().describe('Cached/proxied thumbnail URL served by Brave.'),
+        original: z.string().optional().describe('Original thumbnail URL on the source site.'),
+    })
+        .loose()
+        .optional()
+        .describe('Thumbnail image references (present when enable_source_metadata is true).'),
+})
+    .loose();
+export const LlmContextSearchApiResponseSchema = z.object({
+    grounding: z.object({
+        generic: z
+            .array(z.object({
+            url: z.url(),
+            title: z.string(),
+            snippets: SnippetsSchema,
+        }))
+            .describe(`Array of LLM context items with extracted web content.`),
+        poi: z
+            .object({
+            name: z.string(),
+            url: z.url(),
+            title: z.string(),
+            snippets: SnippetsSchema,
+        })
+            .nullable()
+            .optional()
+            .describe(`A point of interest item returned for local recall queries.`),
+        map: z
+            .array(z.object({
+            name: z.string(),
+            url: z.union([z.url(), z.literal('')]),
+            title: z.string(),
+            snippets: SnippetsSchema,
+        }))
+            .describe(`Map/place results. When enable_local is enabled, the response may include map data.`),
+    }),
+    sources: z
+        .record(z.url(), SourceMetadataSchema)
+        .describe(`Metadata for each referenced URL, keyed by URL. Known fields include title, hostname, and age; site_name, favicon, and thumbnail are present when enable_source_metadata is true. Unknown fields are preserved as-is.`),
+});

package/dist/tools/local/index.js

@@ -16,7 +16,7 @@ export const description = `
         - Phone numbers and opening hours
 
     Use this when the query implies 'near me', 'in my area', or mentions specific locations (e.g., 'in San Francisco'). This tool automatically falls back to brave_web_search if no local results are found.
-`;
+`.trim();
 // Access to Local API is available through the Pro plans.
 export const execute = async (params) => {
     // Make sure both 'web' and 'locations' are in the result_filter

package/dist/tools/news/index.js

@@ -23,7 +23,7 @@ export const description = `
         - "According to [Reuters](https://www.reuters.com/technology/china-bans/), China bans uncertified and recalled power banks on planes".
         - "The [New York Times](https://www.nytimes.com/2025/06/27/us/technology/ev-sales.html) reports that Tesla's EV sales have increased by 20%".
         - "According to [BBC News](https://www.bbc.com/news/world-europe-65910000), the UK government has announced a new policy to support renewable energy".
-`;
+`.trim();
 export const execute = async (params) => {
     const response = await API.issueRequest('news', params);
     return {

package/dist/tools/news/params.js

@@ -45,8 +45,12 @@ export const params = z.object({
         .describe("Filters search results for adult content. The following values are supported: 'off' - No filtering. 'moderate' - Filter out explicit content. 'strict' - Filter out explicit and suggestive content. The default value is 'moderate'.")
         .optional(),
     freshness: z
-        .union([z.literal('pd'), z.literal('pw'), z.literal('pm'), z.literal('py'), z.string()])
-        .default('pd')
+        .union([
+        z.enum(['pd', 'pw', 'pm', 'py']),
+        z
+            .string()
+            .regex(/^\d{4}-\d{2}-\d{2}to\d{4}-\d{2}-\d{2}$/, "Use 'pd', 'pw', 'pm', or 'py' for a relative discovery window, or a custom range as YYYY-MM-DDtoYYYY-MM-DD (e.g. 2022-04-01to2022-07-30)."),
+    ])
         .describe("Filters search results by when they were discovered. The following values are supported: 'pd' - Discovered within the last 24 hours. 'pw' - Discovered within the last 7 Days. 'pm' - Discovered within the last 31 Days. 'py' - Discovered within the last 365 Days. 'YYYY-MM-DDtoYYYY-MM-DD' - Timeframe is also supported by specifying the date range e.g. 2022-04-01to2022-07-30.")
         .optional(),
     extra_snippets: z
@@ -55,8 +59,8 @@ export const params = z.object({
         .describe('A snippet is an excerpt from a page you get as a result of the query, and extra_snippets allow you to get up to 5 additional, alternative excerpts. Only available under Free AI, Base AI, Pro AI, Base Data, Pro Data and Custom plans.')
         .optional(),
     goggles: z
-        .array(z.string())
-        .describe("Goggles act as a custom re-ranking on top of Brave's search index. The parameter supports both a url where the Goggle is hosted or the definition of the Goggle. For more details, refer to the Goggles repository (i.e., https://github.com/brave/goggles-quickstart).")
+        .union([z.string(), z.array(z.string())])
+        .describe("Goggles act as a custom re-ranking on top of Brave's search index. The parameter supports both a url where the Goggle is hosted or the definition of the Goggle. Multiple goggle URLs and/or definitions can be provided in an array. For more details, refer to the Goggles repository (i.e., https://github.com/brave/goggles-quickstart).")
         .optional(),
 });
 export default params;

package/dist/tools/place_search/index.js

@@ -0,0 +1,52 @@
+import API from '../../BraveAPI/index.js';
+import { RequestParamsSchema, RequestHeadersSchema, PlaceSearchInputSchema, } from './schemas/input.js';
+import { PlaceSearchApiResponseSchema } from './schemas/output.js';
+export const name = 'brave_place_search';
+export const annotations = {
+    title: 'Brave Place Search',
+    openWorldHint: true,
+};
+export const description = `
+    Searches Brave's Place Search API. A single call may populate any combination of 'results' (POIs), 'cities', 'addresses', 'streets', and 'location' (the resolved search area), depending on the query's shape.
+
+    When to use:
+        - POIs near coordinates or a named area (e.g. "coffee shops in Paris") -> 'results', each with structured business data (postal address, hours, contact, ratings, photos, categories, timezone).
+        - Browsing general POIs (omit 'query'; supply 'latitude'+'longitude' or 'location').
+        - Disambiguating a bare city name (e.g. "springfield") -> 'cities'.
+        - Resolving a specific address (e.g. "350 5th avenue" with NYC coords) -> 'addresses' (often plus 'streets').
+        - Looking up a street by name (e.g. "michigan avenue" with Chicago coords) -> 'streets'.
+
+    Inputs:
+        - Anchor the search via 'latitude'+'longitude' or 'location' (or both). With neither, 'query' is required.
+        - 'addresses' / 'streets' only surface when the query is address-/street-shaped AND geographically anchored.
+        - 'location' format: US -- '<city> <state> <country>' (e.g. 'san francisco ca united states'); non-US -- '<city> <country>' (e.g. 'tokyo japan'). Capitalization and commas don't matter.
+        - 'count' caps results (max 50, default 20). 'radius' (meters) biases toward closer results; it does NOT hard-limit the search area.
+`.trim();
+export const execute = async (params) => {
+    const parsedParams = RequestParamsSchema.parse(params);
+    const parsedHeaders = RequestHeadersSchema.parse(params);
+    const response = await API.issueRequest('placeSearch', parsedParams, parsedHeaders);
+    return {
+        content: [{ type: 'text', text: JSON.stringify(response) }],
+        isError: false,
+        structuredContent: response,
+    };
+};
+export const register = (mcpServer) => {
+    mcpServer.registerTool(name, {
+        title: name,
+        description: description,
+        inputSchema: PlaceSearchInputSchema.shape,
+        outputSchema: PlaceSearchApiResponseSchema.shape,
+        annotations: annotations,
+    }, execute);
+};
+export default {
+    name,
+    description,
+    annotations,
+    inputSchema: PlaceSearchInputSchema.shape,
+    outputSchema: PlaceSearchApiResponseSchema.shape,
+    execute,
+    register,
+};

package/dist/tools/place_search/schemas/input.js

@@ -0,0 +1,216 @@
+import { z } from 'zod';
+/**
+ * Keep up-to-date with documentation:
+ * https://api-dashboard.search.brave.com/api-reference/web/place_search
+ */
+const CountryCodesSchema = z.enum([
+    'AR',
+    'AU',
+    'AT',
+    'BE',
+    'BR',
+    'CA',
+    'CL',
+    'DK',
+    'FI',
+    'FR',
+    'DE',
+    'GR',
+    'HK',
+    'IN',
+    'ID',
+    'IT',
+    'JP',
+    'KR',
+    'MY',
+    'MX',
+    'NL',
+    'NZ',
+    'NO',
+    'CN',
+    'PL',
+    'PT',
+    'PH',
+    'RU',
+    'SA',
+    'ZA',
+    'ES',
+    'SE',
+    'CH',
+    'TW',
+    'TR',
+    'GB',
+    'US',
+]);
+const SearchLangCodesSchema = z.enum([
+    'ar',
+    'eu',
+    'bn',
+    'bg',
+    'ca',
+    'zh-hans',
+    'zh-hant',
+    'hr',
+    'cs',
+    'da',
+    'nl',
+    'en',
+    'en-gb',
+    'et',
+    'fi',
+    'fr',
+    'gl',
+    'de',
+    'el',
+    'gu',
+    'he',
+    'hi',
+    'hu',
+    'is',
+    'it',
+    'jp',
+    'kn',
+    'ko',
+    'lv',
+    'lt',
+    'ms',
+    'ml',
+    'mr',
+    'nb',
+    'pl',
+    'pt-br',
+    'pt-pt',
+    'pa',
+    'ro',
+    'ru',
+    'sr',
+    'sk',
+    'sl',
+    'es',
+    'sv',
+    'ta',
+    'te',
+    'th',
+    'tr',
+    'uk',
+    'vi',
+]);
+const UiLangCodesSchema = z.enum([
+    'es-AR',
+    'en-AU',
+    'de-AT',
+    'nl-BE',
+    'fr-BE',
+    'pt-BR',
+    'en-CA',
+    'fr-CA',
+    'es-CL',
+    'da-DK',
+    'fi-FI',
+    'fr-FR',
+    'de-DE',
+    'zh-HK',
+    'en-IN',
+    'en-ID',
+    'it-IT',
+    'ja-JP',
+    'ko-KR',
+    'en-MY',
+    'es-MX',
+    'nl-NL',
+    'en-NZ',
+    'no-NO',
+    'zh-CN',
+    'pl-PL',
+    'en-PH',
+    'ru-RU',
+    'en-ZA',
+    'es-ES',
+    'sv-SE',
+    'fr-CH',
+    'de-CH',
+    'zh-TW',
+    'tr-TR',
+    'en-GB',
+    'en-US',
+    'es-US',
+]);
+export const RequestParamsSchema = z.object({
+    query: z
+        .string()
+        .trim()
+        .max(400)
+        .refine((str) => str.length === 0 || str.split(/\s+/).length <= 50, 'Query cannot exceed 50 words')
+        .transform((str) => (str.length === 0 ? undefined : str))
+        .describe('Query string. Shape influences the response: POI-like queries -> `results`; bare/ambiguous city names -> `cities`; address- or street-shaped queries with a geographic anchor -> `addresses` and/or `streets`. If omitted, returns general POIs in the supplied area.')
+        .optional(),
+    radius: z
+        .number()
+        .min(0)
+        .describe('Bias toward results closer to the supplied coordinates, in meters. NOT a hard cutoff -- the API may still return more distant results. If omitted, the search is performed globally.')
+        .optional(),
+    count: z
+        .number()
+        .int()
+        .min(1)
+        .max(50)
+        .describe('Number of results to return. Maximum is 50. Default is 20.')
+        .optional(),
+    latitude: z
+        .number()
+        .min(-90)
+        .max(90)
+        .describe('Latitude of the geographical coordinates around which to search, in degrees (-90 to 90). Typically paired with `longitude`.')
+        .optional(),
+    longitude: z
+        .number()
+        .min(-180)
+        .max(180)
+        .describe('Longitude of the geographical coordinates around which to search, in degrees (-180 to 180). Typically paired with `latitude`.')
+        .optional(),
+    location: z
+        .string()
+        .trim()
+        .min(1)
+        .describe("Location string to search around, used as an alternative to `latitude` and `longitude`. For US locations prefer the form '<city> <state> <country name>' (e.g. 'san francisco ca united states'); for non-US locations use '<city> <country name>' (e.g. 'tokyo japan'). No commas or special characters needed; capitalization does not matter.")
+        .optional(),
+    country: CountryCodesSchema.describe("Two-letter country code (ISO 3166-1 alpha-2) used to scope the search. Defaults to 'US'.").optional(),
+    search_lang: SearchLangCodesSchema.describe("Language for the search results. Defaults to 'en'.").optional(),
+    ui_lang: UiLangCodesSchema.describe("User interface language for the response, usually of the form '<language>-<region>'. Defaults to 'en-US'.").optional(),
+    units: z
+        .enum(['metric', 'imperial'])
+        .describe("Units of measurement for distance values. Defaults to 'metric'.")
+        .optional(),
+    safesearch: z
+        .enum(['off', 'moderate', 'strict'])
+        .describe("Safe search level for the query results. 'off' - No filtering. 'moderate' - Filter out explicit content. 'strict' - Filter out explicit and suggestive content. Defaults to 'strict'.")
+        .optional(),
+    spellcheck: z
+        .boolean()
+        .describe('Whether to apply spellcheck before executing the search. Defaults to true.')
+        .optional(),
+    geoloc: z.string().describe('Optional geolocation token used to refine results.').optional(),
+});
+export const RequestHeadersSchema = z.object({
+    'api-version': z
+        .string()
+        .regex(/^\d{4}-\d{2}-\d{2}$/)
+        .describe('The API version to use. This is denoted by the format YYYY-MM-DD. Default is the latest that is available. Read more about API versioning at https://api-dashboard.search.brave.com/documentation/guides/versioning.')
+        .optional(),
+    accept: z
+        .enum(['application/json', '*/*'])
+        .describe('The default supported media type is application/json.')
+        .optional(),
+    'cache-control': z
+        .literal('no-cache')
+        .describe('Brave Search will return cached content by default. To prevent caching set the Cache-Control header to no-cache. This is currently done as best effort.')
+        .optional(),
+    'user-agent': z
+        .string()
+        .describe('The user agent originating the request. Brave Search can utilize the user agent to provide a different experience depending on the device as described by the string. The user agent should follow the commonly used browser agent strings on each platform. For more information on curating user agents, see RFC 9110.')
+        .optional(),
+});
+export const PlaceSearchInputSchema = z.object({
+    ...RequestParamsSchema.shape,
+    ...RequestHeadersSchema.shape,
+});

package/dist/tools/place_search/schemas/output.js

@@ -0,0 +1,249 @@
+import { z } from 'zod';
+/**
+ * Keep up to date with documentation:
+ * https://api-dashboard.search.brave.com/api-reference/web/place_search#responses
+ */
+const CoordinatesSchema = z
+    .tuple([z.number(), z.number()])
+    .describe('Latitude/longitude pair for the location, when available.');
+const ThumbnailSchema = z.looseObject({
+    src: z.string().describe('The served URL of the picture thumbnail.'),
+    alt: z.string().describe('The alt text for the thumbnail.').optional(),
+    height: z.number().describe('The height of the thumbnail.').optional(),
+    width: z.number().describe('The width of the thumbnail.').optional(),
+    bg_color: z.string().describe('The background color of the thumbnail.').optional(),
+    original: z.url().describe('The original URL of the image.').optional(),
+    logo: z.boolean().describe('Whether the thumbnail is a logo.').optional(),
+    duplicated: z.boolean().describe('Whether the thumbnail is duplicated.').optional(),
+    theme: z.string().describe('The theme of the thumbnail (e.g. "light", "dark").').optional(),
+});
+const PostalAddressSchema = z.looseObject({
+    type: z.literal('PostalAddress'),
+    country: z.string().describe('The country associated with the location.').optional(),
+    postalCode: z.string().describe('The postal code associated with the location.').optional(),
+    streetAddress: z.string().describe('The street address associated with the location.').optional(),
+    addressRegion: z
+        .string()
+        .describe('The region associated with the location. Usually a state.')
+        .optional(),
+    addressLocality: z
+        .string()
+        .describe('The address locality or subregion associated with the location.')
+        .optional(),
+    displayAddress: z.string().describe('The displayed address string.'),
+});
+const DayOpeningHoursSchema = z.looseObject({
+    abbr_name: z.string().describe('Short name of the day of the week (e.g. "Mon").').optional(),
+    full_name: z.string().describe('Full name of the day of the week (e.g. "Monday").').optional(),
+    opens: z.string().describe('Opening time in 24h format (e.g. "09:00").').optional(),
+    closes: z.string().describe('Closing time in 24h format (e.g. "17:00").').optional(),
+});
+const OpeningHoursSchema = z.looseObject({
+    current_day: z
+        .array(DayOpeningHoursSchema)
+        .describe('Opening hours for the current day. May contain multiple entries when the location closes and reopens during the day.')
+        .optional(),
+    days: z
+        .array(z.union([DayOpeningHoursSchema, z.array(DayOpeningHoursSchema)]))
+        .describe('Opening hours for the rest of the week. Each entry may itself be either a single day-hours object or an array of day-hours objects (when a day has multiple open/close intervals).')
+        .optional(),
+});
+const ContactSchema = z.looseObject({
+    email: z.string().describe('Contact email for the business.').optional(),
+    telephone: z.string().describe('Contact telephone number for the business.').optional(),
+});
+const DistanceSchema = z.looseObject({
+    value: z.number().describe('The quantity of the unit.'),
+    units: z.string().describe('The name of the unit associated with the quantity.'),
+});
+const ProfileSchema = z.looseObject({
+    type: z.string().optional(),
+    name: z.string().optional(),
+    long_name: z.string().optional(),
+    url: z.string().optional(),
+    img: z.string().optional(),
+});
+const RatingSchema = z.looseObject({
+    ratingValue: z.number().describe('The current value of the rating.').optional(),
+    bestRating: z.number().describe('Highest possible rating value.').optional(),
+    reviewCount: z.number().describe('Number of reviews backing the rating.').optional(),
+    profile: ProfileSchema.optional(),
+    is_tripadvisor: z
+        .boolean()
+        .describe('Whether the rating originates from Tripadvisor.')
+        .optional(),
+});
+const ReviewSchema = z.looseObject({
+    title: z.string().describe('The title of the review.'),
+    description: z.string().describe('A description seen in the review.'),
+    date: z.string().describe('The date when the review was published.'),
+    rating: RatingSchema.optional(),
+    author: ProfileSchema.optional(),
+});
+const ReviewsSchema = z.looseObject({
+    results: z
+        .array(ReviewSchema)
+        .describe('A list of trip advisor reviews for the entity.')
+        .optional(),
+    viewMoreUrl: z
+        .string()
+        .describe('A URL to a web page where more information on the result can be seen.')
+        .optional(),
+    reviews_in_foreign_language: z
+        .boolean()
+        .describe('Any reviews available in a foreign language.')
+        .optional(),
+});
+const PicturesSchema = z.looseObject({
+    viewMoreUrl: z.string().describe('URL where additional pictures can be viewed.').optional(),
+    results: z.array(ThumbnailSchema).describe('Thumbnail entries for the location.').optional(),
+});
+const ActionSchema = z.looseObject({
+    type: z.string().describe('The type representing the action.'),
+    url: z.string().describe('A URL representing the action to be taken.'),
+});
+const MetaUrlSchema = z.looseObject({
+    scheme: z.string().describe('The protocol scheme extracted from the URL.'),
+    netloc: z.string().describe('The network location part extracted from the URL.'),
+    hostname: z.string().describe('The lowercased domain name extracted from the URL.').optional(),
+    favicon: z.string().describe('The favicon used for the URL.').optional(),
+    path: z
+        .string()
+        .describe('The hierarchical path of the URL useful as a display string.')
+        .optional(),
+});
+/**
+ * Fields shared by every "web-style" result entry: both inline web results
+ * (which decorate location results via `results`) and the location/POI
+ * results themselves. Defined once and composed via `.extend()` below.
+ */
+const WebResultBaseSchema = z.looseObject({
+    title: z.string().describe('The display title of the location.'),
+    url: z
+        .union([z.url(), z.literal('')])
+        .describe('Primary URL associated with the location. May be an empty string.'),
+    is_source_local: z.boolean().describe('Whether the result is from local sources.'),
+    is_source_both: z.boolean().describe('Whether the result is from both local and global sources.'),
+    description: z
+        .string()
+        .describe('Short description of the location (e.g. "Plaza", "Theater").')
+        .optional(),
+    page_age: z.string().describe('The age of the page as a date string.').optional(),
+    page_fetched: z
+        .string()
+        .describe('The date the page was last fetched as a date string.')
+        .optional(),
+    fetched_content_timestamp: z
+        .number()
+        .describe('The timestamp of the content when it was fetched.')
+        .optional(),
+    profile: ProfileSchema.describe('The profile associated with the result.').optional(),
+    language: z.string().describe('The language of the page.').optional(),
+    family_friendly: z.boolean().describe('Whether the result is family friendly.').optional(),
+});
+/**
+ * An inline web result attached to a location (under `LocationResultSchema.results`).
+ */
+const WebResultSchema = WebResultBaseSchema.extend({
+    meta_url: MetaUrlSchema.optional(),
+});
+/**
+ * A location/POI result. Used both at the top level (`results[]`) and inside
+ * addresses (`pois[]` / `pois_nearby[]`).
+ */
+const LocationResultSchema = WebResultBaseSchema.extend({
+    type: z.literal('location_result').describe('Result type identifier.'),
+    provider_url: z
+        .union([z.url(), z.literal('')])
+        .describe('URL of the upstream provider for this result. May be an empty string.'),
+    coordinates: CoordinatesSchema.optional(),
+    zoom_level: z.number().describe('Suggested zoom level when displaying on a map.'),
+    thumbnail: ThumbnailSchema.describe('The thumbnail associated with the location.').optional(),
+    postal_address: PostalAddressSchema.describe('The postal address of the location.').optional(),
+    opening_hours: OpeningHoursSchema.describe('The opening hours of the location.').optional(),
+    contact: ContactSchema.describe('The contact of the location.').optional(),
+    price_range: z
+        .string()
+        .describe('Price classification string for the business (e.g. "$", "$$").')
+        .optional(),
+    rating: RatingSchema.describe('The rating of the result.').optional(),
+    distance: DistanceSchema.describe("Distance from the user's geolocation, if available.").optional(),
+    profiles: z
+        .array(ProfileSchema)
+        .describe('External profiles (e.g. data providers) associated with the result.')
+        .optional(),
+    reviews: ReviewsSchema.describe('Reviews associated with the result.').optional(),
+    pictures: PicturesSchema.describe('Pictures associated with the result.').optional(),
+    action: ActionSchema.describe('The action associated with the result.').optional(),
+    serves_cuisine: z.array(z.string()).describe('List of cuisine categories served.').optional(),
+    categories: z.array(z.string()).describe('List of category labels.').optional(),
+    icon_category: z.string().describe('Suggested icon category (e.g. "cafe").').optional(),
+    timezone: z.string().describe('IANA timezone identifier for the location.').optional(),
+    timezone_offset: z
+        .number()
+        .describe("UTC offset of the location's timezone, in minutes.")
+        .optional(),
+    id: z
+        .string()
+        .describe('Temporary identifier for the location, valid for ~8 hours. Can be used with brave_local_search-style endpoints to fetch additional information.')
+        .optional(),
+    results: z.array(WebResultSchema).describe('Web results related to this location.').optional(),
+});
+const QuerySchema = z.looseObject({
+    original: z
+        .string()
+        .describe('The original query string as supplied by the caller (may be empty).'),
+    altered: z
+        .string()
+        .describe('The altered query string as supplied by the caller (may be empty).')
+        .optional(),
+    spellcheck_off: z.boolean().optional(),
+    show_strict_warning: z.boolean().optional(),
+});
+const AddressSchema = z.looseObject({
+    type: z
+        .enum(['address', 'street'])
+        .describe('Result is "address" when the result refers to an explicit street + number, but "street" when it refers only to the street itself.'),
+    name: z.string().describe('The name of the address.'),
+    coordinates: CoordinatesSchema.describe('Latitude/longitude of the address'),
+    pois: z.array(LocationResultSchema).describe('List of POIs located at this address.'),
+    pois_nearby: z.array(LocationResultSchema).describe('List of POIs nearby this address.'),
+    zoom_level: z.number().describe('Suggested zoom level when displaying on a map.'),
+    distance: DistanceSchema.describe("Distance from the user's geolocation, if available.").optional(),
+    postal_address: PostalAddressSchema.describe('The postal address of the address.').optional(),
+});
+const CitySchema = z.looseObject({
+    type: z.literal('city'),
+    name: z.string().describe('Name of the city'),
+    country: z.string().describe('ISO country code for the city'),
+    coordinates: CoordinatesSchema.describe('Latitude/longitude of the city'),
+    thumbnail: ThumbnailSchema.describe('Primary image for the city'),
+});
+const LocationSchema = z.looseObject({
+    coordinates: CoordinatesSchema.describe('Latitude/longitude of the resolved search area.'),
+    name: z.string().describe('Human-readable name of the resolved search area.').optional(),
+    country: z.string().describe('ISO country code for the resolved search area.').optional(),
+});
+export const PlaceSearchApiResponseSchema = z.looseObject({
+    type: z
+        .literal('locations')
+        .describe('Top-level response discriminator. Always "locations" for Place Search.'),
+    query: QuerySchema.optional(),
+    results: z
+        .array(LocationResultSchema)
+        .describe('Points of interest matching the search. Populated for POI-shaped queries.')
+        .optional(),
+    cities: z
+        .array(CitySchema)
+        .describe('City matches for the query. Typically populated when the query is a bare or ambiguous city name (e.g. "springfield", "san francisco").')
+        .optional(),
+    addresses: z
+        .array(AddressSchema)
+        .describe('Address matches. Typically populated when the query is a street + number AND is geographically anchored via `latitude`+`longitude` or a specific `location`.')
+        .optional(),
+    streets: z
+        .array(AddressSchema)
+        .describe('Street matches. Typically populated when the query is a street name AND is geographically anchored via `latitude`+`longitude` or a specific `location`.')
+        .optional(),
+    location: LocationSchema.describe('The search area as resolved by the API (e.g. coordinates + city name). Useful for confirming the API interpreted the input as expected and for grounding follow-up queries.').optional(),
+});

package/dist/tools/summarizer/index.js

@@ -18,7 +18,7 @@ export const description = `
     Returns a text summary that consolidates information from the search results. Optional features include inline references to source URLs and additional entity information.
 
     Requirements: Must first perform a web search using brave_web_search with summary=true parameter. Requires a Pro AI subscription to access the summarizer functionality.
-`;
+`.trim();
 export const execute = async (params) => {
     const response = { content: [], isError: false };
     try {

package/dist/tools/videos/index.js

@@ -14,7 +14,7 @@ export const description = `
         - Useful for discovering video content, getting video metadata, or finding videos from specific creators/publishers.
 
     Returns a JSON list of video-related results with title, url, description, duration, and thumbnail_url.
-`;
+`.trim();
 export const execute = async (params) => {
     const response = await API.issueRequest('videos', params);
     return {

package/dist/tools/videos/params.js

@@ -46,7 +46,12 @@ export const params = z.object({
         .describe("Filters search results for adult content. The following values are supported: 'off' - No filtering. 'moderate' - Filter out explicit content. 'strict' - Filter out explicit and suggestive content. The default value is 'moderate'.")
         .optional(),
     freshness: z
-        .union([z.literal('pd'), z.literal('pw'), z.literal('pm'), z.literal('py'), z.string()])
+        .union([
+        z.enum(['pd', 'pw', 'pm', 'py']),
+        z
+            .string()
+            .regex(/^\d{4}-\d{2}-\d{2}to\d{4}-\d{2}-\d{2}$/, "Use 'pd', 'pw', 'pm', or 'py' for a relative discovery window, or a custom range as YYYY-MM-DDtoYYYY-MM-DD (e.g. 2022-04-01to2022-07-30)."),
+    ])
         .describe("Filters search results by when they were discovered. The following values are supported: 'pd' - Discovered within the last 24 hours. 'pw' - Discovered within the last 7 days. 'pm' - Discovered within the last 31 days. 'py' - Discovered within the last 365 days. 'YYYY-MM-DDtoYYYY-MM-DD' - timeframe is also supported by specifying the date range (e.g. '2022-04-01to2022-07-30').")
         .optional(),
 });