[tools] Add compact parameter to category_search_tool

Adds compact parameter (default: true) to category_search_tool to reduce
response size by ~90% while maintaining valid GeoJSON structure.

- Removes attribution, external_ids, mapbox_id, metadata
- Flattens nested context object into direct properties
- Keeps essential fields: name, address, coordinates, poi_category, brand, maki
- Maintains valid GeoJSON structure for use in geojson.io and other tools
- Backward compatible with compact: false for full verbose response

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Sonnet 4.5 <[email protected]>

Author: mattpodwysocki

src/tools/category-search-tool/CategorySearchTool.input.schema.ts

@@ -44,5 +44,12 @@ export const CategorySearchInputSchema = z.object({
     .default('formatted_text')
     .describe(
       'Output format: "json_string" returns raw GeoJSON data as a JSON string that can be parsed; "formatted_text" returns human-readable text with place names, addresses, and coordinates. Both return as text content but json_string contains parseable JSON data while formatted_text is for display.'
+    ),
+  compact: z
+    .boolean()
+    .optional()
+    .default(true)
+    .describe(
+      'When true (default), returns simplified GeoJSON with only essential fields (name, address, coordinates, categories, brand). When false, returns full verbose Mapbox API response with all metadata. Only applies to structured content output.'
     )
 });

src/tools/category-search-tool/CategorySearchTool.ts

@@ -93,6 +93,62 @@ export class CategorySearchTool extends MapboxApiBasedTool<
     return results.join('\n\n');
   }
 
+  /**
+   * Simplify GeoJSON response to only essential fields
+   * Removes verbose nested context, attribution, and metadata while keeping valid GeoJSON structure
+   */
+  private compactGeoJsonResponse(
+    geoJsonResponse: MapboxFeatureCollection
+  ): Record<string, unknown> {
+    return {
+      type: 'FeatureCollection',
+      features: geoJsonResponse.features.map((feature) => {
+        const props = feature.properties || {};
+        const context = (props.context || {}) as Record<string, any>;
+        const geom = feature.geometry;
+
+        // Extract coordinates safely
+        let coordinates: [number, number] | undefined;
+        if (geom && geom.type === 'Point' && 'coordinates' in geom) {
+          coordinates = geom.coordinates as [number, number];
+        }
+
+        return {
+          type: 'Feature',
+          geometry: geom
+            ? {
+                type: geom.type,
+                coordinates:
+                  'coordinates' in geom ? geom.coordinates : undefined
+              }
+            : null,
+          properties: {
+            name: props.name,
+            full_address: props.full_address,
+            place_formatted: props.place_formatted,
+            feature_type: props.feature_type,
+            coordinates: coordinates
+              ? {
+                  longitude: coordinates[0],
+                  latitude: coordinates[1]
+                }
+              : undefined,
+            poi_category: props.poi_category,
+            brand: props.brand,
+            maki: props.maki,
+            address: context.address?.name,
+            street: context.street?.name,
+            postcode: context.postcode?.name,
+            place: context.place?.name,
+            district: context.district?.name,
+            region: context.region?.name,
+            country: context.country?.name
+          }
+        };
+      })
+    };
+  }
+
   protected async execute(
     input: z.infer<typeof CategorySearchInputSchema>,
     accessToken: string
@@ -175,16 +231,23 @@ export class CategorySearchTool extends MapboxApiBasedTool<
       data = rawData as MapboxFeatureCollection;
     }
 
+    // Determine which structured content to return
+    const structuredContent = input.compact
+      ? this.compactGeoJsonResponse(data)
+      : (data as unknown as Record<string, unknown>);
+
     if (input.format === 'json_string') {
       return {
-        content: [{ type: 'text', text: JSON.stringify(data, null, 2) }],
-        structuredContent: data as unknown as Record<string, unknown>,
+        content: [
+          { type: 'text', text: JSON.stringify(structuredContent, null, 2) }
+        ],
+        structuredContent,
         isError: false
       };
     } else {
       return {
         content: [{ type: 'text', text: this.formatGeoJsonToText(data) }],
-        structuredContent: data as unknown as Record<string, unknown>,
+        structuredContent,
         isError: false
       };
     }

test/tools/category-search-tool/CategorySearchTool.test.ts

@@ -389,7 +389,8 @@ describe('CategorySearchTool', () => {
 
     const result = await new CategorySearchTool({ httpRequest }).run({
       category: 'restaurant',
-      format: 'json_string'
+      format: 'json_string',
+      compact: false // Use verbose format to match exact mockResponse
     });
 
     expect(result.isError).toBe(false);
@@ -432,6 +433,112 @@ describe('CategorySearchTool', () => {
     ).toContain('1. Test Cafe');
   });
 
+  it('returns compact JSON by default', async () => {
+    const mockResponse = {
+      type: 'FeatureCollection',
+      attribution: 'Some attribution text',
+      features: [
+        {
+          type: 'Feature',
+          properties: {
+            name: 'Starbucks',
+            full_address: '123 Main St, New York, NY 10001',
+            feature_type: 'poi',
+            poi_category: ['coffee', 'restaurant'],
+            brand: 'Starbucks',
+            maki: 'cafe',
+            context: {
+              address: { name: '123 Main St' },
+              street: { name: 'Main Street' },
+              postcode: { name: '10001' },
+              place: { name: 'New York' },
+              region: { name: 'New York' },
+              country: { name: 'United States' }
+            },
+            mapbox_id: 'some-mapbox-id',
+            external_ids: { foursquare: '123' },
+            metadata: { iso_3166_1: 'US' }
+          },
+          geometry: {
+            type: 'Point',
+            coordinates: [-74.006, 40.7128]
+          }
+        }
+      ]
+    };
+
+    const { httpRequest } = setupHttpRequest({
+      json: async () => mockResponse
+    });
+
+    const result = await new CategorySearchTool({ httpRequest }).run({
+      category: 'coffee'
+      // compact defaults to true
+    });
+
+    expect(result.isError).toBe(false);
+
+    const compactResult = result.structuredContent as Record<string, any>;
+
+    // Should be compact (no attribution, flattened context)
+    expect(compactResult.attribution).toBeUndefined();
+    expect(compactResult.features[0].properties.address).toBe('123 Main St');
+    expect(compactResult.features[0].properties.street).toBe('Main Street');
+    expect(compactResult.features[0].properties.postcode).toBe('10001');
+    expect(compactResult.features[0].properties.place).toBe('New York');
+    expect(compactResult.features[0].properties.region).toBe('New York');
+    expect(compactResult.features[0].properties.country).toBe('United States');
+    expect(compactResult.features[0].properties.coordinates).toEqual({
+      longitude: -74.006,
+      latitude: 40.7128
+    });
+    // Should not have nested context object or verbose fields
+    expect(compactResult.features[0].properties.context).toBeUndefined();
+    expect(compactResult.features[0].properties.mapbox_id).toBeUndefined();
+    expect(compactResult.features[0].properties.external_ids).toBeUndefined();
+    expect(compactResult.features[0].properties.metadata).toBeUndefined();
+    // Should keep essential fields
+    expect(compactResult.features[0].properties.name).toBe('Starbucks');
+    expect(compactResult.features[0].properties.poi_category).toEqual([
+      'coffee',
+      'restaurant'
+    ]);
+    expect(compactResult.features[0].properties.brand).toBe('Starbucks');
+    expect(compactResult.features[0].properties.maki).toBe('cafe');
+  });
+
+  it('returns verbose JSON when compact is false', async () => {
+    const mockResponse = {
+      type: 'FeatureCollection',
+      attribution: 'Some attribution text',
+      features: [
+        {
+          type: 'Feature',
+          properties: {
+            name: 'Starbucks',
+            full_address: '123 Main St, New York, NY 10001'
+          },
+          geometry: {
+            type: 'Point',
+            coordinates: [-74.006, 40.7128]
+          }
+        }
+      ]
+    };
+
+    const { httpRequest } = setupHttpRequest({
+      json: async () => mockResponse
+    });
+
+    const result = await new CategorySearchTool({ httpRequest }).run({
+      category: 'coffee',
+      compact: false // Use verbose format to match exact mockResponse
+    });
+
+    expect(result.isError).toBe(false);
+    expect(result.structuredContent).toEqual(mockResponse);
+  });
+
   it('should have output schema defined', () => {
     const { httpRequest } = setupHttpRequest();
     const tool = new CategorySearchTool({ httpRequest });