@mapbox/mcp-server 0.2.0-issue.11.2 → 0.2.0

package/dist/tools/directions-tool/DirectionsTool.test.js

@@ -1,18 +1,9 @@
-process.env.MAPBOX_ACCESS_TOKEN = 'test.token.signature';
+process.env.MAPBOX_ACCESS_TOKEN =
+    'eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiJ0ZXN0In0.signature';
 import { cleanup } from '../../utils/requestUtils.js';
 import { setupFetch, assertHeadersSent } from '../../utils/requestUtils.test-helpers.js';
 import { DirectionsTool } from './DirectionsTool.js';
-import * as cleanResponseModule from './cleanResponseData.js';
 describe('DirectionsTool', () => {
-    beforeEach(() => {
-        // Mock the cleanResponseData function to return data unchanged, this make testing much easier
-        // There should be separate test suits for `cleanResponseData`
-        jest
-            .spyOn(cleanResponseModule, 'cleanResponseData')
-            .mockImplementation((_, data) => data);
-        // Enable verbose errors for testing
-        process.env.VERBOSE_ERRORS = 'true';
-    });
     afterEach(() => {
         jest.restoreAllMocks();
         cleanup();
@@ -21,8 +12,8 @@ describe('DirectionsTool', () => {
         const mockFetch = setupFetch();
         await new DirectionsTool().run({
             coordinates: [
-                [-74.102094, 40.692815],
-                [-74.1022094, 40.792815]
+                { longitude: -74.102094, latitude: 40.692815 },
+                { longitude: -74.1022094, latitude: 40.792815 }
             ]
         });
         assertHeadersSent(mockFetch);
@@ -31,8 +22,8 @@ describe('DirectionsTool', () => {
         const mockFetch = setupFetch();
         await new DirectionsTool().run({
             coordinates: [
-                [-73.989, 40.733],
-                [-73.979, 40.743]
+                { longitude: -73.989, latitude: 40.733 },
+                { longitude: -73.979, latitude: 40.743 }
             ]
         });
         const calledUrl = mockFetch.mock.calls[0][0];
@@ -45,13 +36,14 @@ describe('DirectionsTool', () => {
         const mockFetch = setupFetch();
         await new DirectionsTool().run({
             coordinates: [
-                [-122.42, 37.78],
-                [-122.4, 37.79],
-                [-122.39, 37.77]
+                { longitude: -122.42, latitude: 37.78 },
+                { longitude: -122.4, latitude: 37.79 },
+                { longitude: -122.39, latitude: 37.77 }
             ],
             routing_profile: 'walking',
             geometries: 'geojson',
             alternatives: true,
+            annotations: ['distance', 'duration', 'speed'],
             exclude: 'ferry'
         });
         const calledUrl = mockFetch.mock.calls[0][0];
@@ -59,7 +51,7 @@ describe('DirectionsTool', () => {
         expect(calledUrl).toContain('-122.42%2C37.78%3B-122.4%2C37.79%3B-122.39%2C37.77');
         expect(calledUrl).toContain('geometries=geojson');
         expect(calledUrl).toContain('alternatives=true');
-        expect(calledUrl).toContain('annotations=distance%2Cspeed');
+        expect(calledUrl).toContain('annotations=distance%2Cduration%2Cspeed');
         expect(calledUrl).toContain('overview=full');
         expect(calledUrl).toContain('exclude=ferry');
         assertHeadersSent(mockFetch);
@@ -68,32 +60,15 @@ describe('DirectionsTool', () => {
         const mockFetch = setupFetch();
         await new DirectionsTool().run({
             coordinates: [
-                [-118.24, 34.05],
-                [-118.3, 34.02]
+                { longitude: -118.24, latitude: 34.05 },
+                { longitude: -118.3, latitude: 34.02 }
             ]
         });
         const calledUrl = mockFetch.mock.calls[0][0];
         expect(calledUrl).toContain('directions/v5/mapbox/driving-traffic');
-        expect(calledUrl).not.toContain('geometries=');
-        expect(calledUrl).toContain('alternatives=false');
-        expect(calledUrl).toContain('annotations=distance%2Ccongestion%2Cspeed');
-        expect(calledUrl).not.toContain('exclude=');
-        assertHeadersSent(mockFetch);
-    });
-    it('handles geometries=none', async () => {
-        const mockFetch = setupFetch();
-        await new DirectionsTool().run({
-            coordinates: [
-                [-118.24, 34.05],
-                [-118.3, 34.02]
-            ],
-            geometries: 'none'
-        });
-        const calledUrl = mockFetch.mock.calls[0][0];
-        expect(calledUrl).toContain('directions/v5/mapbox/driving-traffic');
-        expect(calledUrl).not.toContain('geometries=');
+        expect(calledUrl).toContain('geometries=polyline');
         expect(calledUrl).toContain('alternatives=false');
-        expect(calledUrl).toContain('annotations=distance%2Ccongestion%2Cspeed');
+        expect(calledUrl).not.toContain('annotations=');
         expect(calledUrl).not.toContain('exclude=');
         assertHeadersSent(mockFetch);
     });
@@ -101,8 +76,8 @@ describe('DirectionsTool', () => {
         const mockFetch = setupFetch();
         await new DirectionsTool().run({
             coordinates: [
-                [-74.0, 40.7],
-                [-73.9, 40.8]
+                { longitude: -74.0, latitude: 40.7 },
+                { longitude: -73.9, latitude: 40.8 }
             ],
             exclude: 'toll,point(-73.95 40.75)'
         });
@@ -122,14 +97,14 @@ describe('DirectionsTool', () => {
         });
         const result = await new DirectionsTool().run({
             coordinates: [
-                [-73.989, 40.733],
-                [-73.979, 40.743]
+                { longitude: -73.989, latitude: 40.733 },
+                { longitude: -73.979, latitude: 40.743 }
             ]
         });
         expect(result.is_error).toBe(true);
         expect(result.content[0]).toMatchObject({
             type: 'text',
-            text: 'Request failed with status 404: Not Found'
+            text: 'Internal error has occurred.'
         });
         assertHeadersSent(mockFetch);
     });
@@ -137,7 +112,7 @@ describe('DirectionsTool', () => {
         const tool = new DirectionsTool();
         // Test with only one coordinate (invalid)
         await expect(tool.run({
-            coordinates: [[-73.989, 40.733]]
+            coordinates: [{ longitude: -73.989, latitude: 40.733 }]
         })).resolves.toMatchObject({
             is_error: true
         });
@@ -151,7 +126,10 @@ describe('DirectionsTool', () => {
     it('validates coordinates constraints - maximum allowed', async () => {
         const tool = new DirectionsTool();
         // Create an array of 26 coordinates (one more than allowed)
-        const tooManyCoords = Array(26).fill([-73.989, 40.733]);
+        const tooManyCoords = Array(26).fill({
+            longitude: -73.989,
+            latitude: 40.733
+        });
         await expect(tool.run({
             coordinates: tooManyCoords
         })).resolves.toMatchObject({
@@ -162,8 +140,8 @@ describe('DirectionsTool', () => {
         const mockFetch = setupFetch();
         await new DirectionsTool().run({
             coordinates: [
-                [-73.989, 40.733],
-                [-73.979, 40.743]
+                { longitude: -73.989, latitude: 40.733 },
+                { longitude: -73.979, latitude: 40.743 }
             ]
         });
         const calledUrl = mockFetch.mock.calls[0][0];
@@ -175,20 +153,174 @@ describe('DirectionsTool', () => {
         // Create an array of exactly 25 coordinates (maximum allowed)
         const maxCoords = Array(25)
             .fill(0)
-            .map((_, i) => [-74 + i * 0.01, 40 + i * 0.01]);
+            .map((_, i) => ({ longitude: -74 + i * 0.01, latitude: 40 + i * 0.01 }));
         await new DirectionsTool().run({
             coordinates: maxCoords
         });
         const calledUrl = mockFetch.mock.calls[0][0];
         // Check that all coordinates are properly encoded
         for (let i = 0; i < maxCoords.length; i++) {
-            const [lng, lat] = maxCoords[i];
+            const { longitude: lng, latitude: lat } = maxCoords[i];
             const semicolon = i < 24 ? '%3B' : '';
             const expectedCoord = `${lng}%2C${lat}` + semicolon;
             expect(calledUrl).toContain(expectedCoord);
         }
         assertHeadersSent(mockFetch);
     });
+    describe('walking parameters validations', () => {
+        it('accepts walking_speed with walking profile', async () => {
+            const mockFetch = setupFetch();
+            await new DirectionsTool().run({
+                coordinates: [
+                    { longitude: -73.989, latitude: 40.733 },
+                    { longitude: -73.979, latitude: 40.743 }
+                ],
+                routing_profile: 'walking',
+                walking_speed: 2.5
+            });
+            const calledUrl = mockFetch.mock.calls[0][0];
+            expect(calledUrl).toContain('walking_speed=2.5');
+            assertHeadersSent(mockFetch);
+        });
+        it('accepts walkway_bias with walking profile', async () => {
+            const mockFetch = setupFetch();
+            await new DirectionsTool().run({
+                coordinates: [
+                    { longitude: -73.989, latitude: 40.733 },
+                    { longitude: -73.979, latitude: 40.743 }
+                ],
+                routing_profile: 'walking',
+                walkway_bias: 0.8
+            });
+            const calledUrl = mockFetch.mock.calls[0][0];
+            expect(calledUrl).toContain('walkway_bias=0.8');
+            assertHeadersSent(mockFetch);
+        });
+        it('rejects walking_speed with non-walking profiles', async () => {
+            const tool = new DirectionsTool();
+            // Test with driving profile
+            await expect(tool.run({
+                coordinates: [
+                    { longitude: -73.989, latitude: 40.733 },
+                    { longitude: -73.979, latitude: 40.743 }
+                ],
+                routing_profile: 'driving',
+                walking_speed: 2.0
+            })).resolves.toMatchObject({
+                is_error: true
+            });
+            // Test with cycling profile
+            await expect(tool.run({
+                coordinates: [
+                    { longitude: -73.989, latitude: 40.733 },
+                    { longitude: -73.979, latitude: 40.743 }
+                ],
+                routing_profile: 'cycling',
+                walking_speed: 2.0
+            })).resolves.toMatchObject({
+                is_error: true
+            });
+        });
+        it('rejects walkway_bias with non-walking profiles', async () => {
+            const tool = new DirectionsTool();
+            // Test with driving-traffic profile
+            await expect(tool.run({
+                coordinates: [
+                    { longitude: -73.989, latitude: 40.733 },
+                    { longitude: -73.979, latitude: 40.743 }
+                ],
+                routing_profile: 'driving-traffic',
+                walkway_bias: 0.5
+            })).resolves.toMatchObject({
+                is_error: true
+            });
+            // Test with cycling profile
+            await expect(tool.run({
+                coordinates: [
+                    { longitude: -73.989, latitude: 40.733 },
+                    { longitude: -73.979, latitude: 40.743 }
+                ],
+                routing_profile: 'cycling',
+                walkway_bias: -0.8
+            })).resolves.toMatchObject({
+                is_error: true
+            });
+        });
+        it('validates walking_speed value ranges', async () => {
+            const tool = new DirectionsTool();
+            // Test with value below minimum (0.14 m/s)
+            await expect(tool.run({
+                coordinates: [
+                    { longitude: -73.989, latitude: 40.733 },
+                    { longitude: -73.979, latitude: 40.743 }
+                ],
+                routing_profile: 'walking',
+                walking_speed: 0.1
+            })).resolves.toMatchObject({
+                is_error: true
+            });
+            // Test with value above maximum (6.94 m/s)
+            await expect(tool.run({
+                coordinates: [
+                    { longitude: -73.989, latitude: 40.733 },
+                    { longitude: -73.979, latitude: 40.743 }
+                ],
+                routing_profile: 'walking',
+                walking_speed: 7.5
+            })).resolves.toMatchObject({
+                is_error: true
+            });
+            // Test with valid value
+            const mockFetch = setupFetch();
+            await tool.run({
+                coordinates: [
+                    { longitude: -73.989, latitude: 40.733 },
+                    { longitude: -73.979, latitude: 40.743 }
+                ],
+                routing_profile: 'walking',
+                walking_speed: 3.0
+            });
+            const calledUrl = mockFetch.mock.calls[0][0];
+            expect(calledUrl).toContain('walking_speed=3');
+        });
+        it('validates walkway_bias value ranges', async () => {
+            const tool = new DirectionsTool();
+            // Test with value below minimum (-1)
+            await expect(tool.run({
+                coordinates: [
+                    { longitude: -73.989, latitude: 40.733 },
+                    { longitude: -73.979, latitude: 40.743 }
+                ],
+                routing_profile: 'walking',
+                walkway_bias: -1.5
+            })).resolves.toMatchObject({
+                is_error: true
+            });
+            // Test with value above maximum (1)
+            await expect(tool.run({
+                coordinates: [
+                    { longitude: -73.989, latitude: 40.733 },
+                    { longitude: -73.979, latitude: 40.743 }
+                ],
+                routing_profile: 'walking',
+                walkway_bias: 1.2
+            })).resolves.toMatchObject({
+                is_error: true
+            });
+            // Test with valid values
+            const mockFetch = setupFetch();
+            await tool.run({
+                coordinates: [
+                    { longitude: -73.989, latitude: 40.733 },
+                    { longitude: -73.979, latitude: 40.743 }
+                ],
+                routing_profile: 'walking',
+                walkway_bias: -0.5
+            });
+            const calledUrl = mockFetch.mock.calls[0][0];
+            expect(calledUrl).toContain('walkway_bias=-0.5');
+        });
+    });
     describe('exclude parameter and routing profile validations', () => {
         it('accepts driving-specific exclusions with driving profiles', async () => {
             const mockFetch = setupFetch();
@@ -196,8 +328,8 @@ describe('DirectionsTool', () => {
             // Test with driving profile
             await expect(tool.run({
                 coordinates: [
-                    [-73.989, 40.733],
-                    [-73.979, 40.743]
+                    { longitude: -73.989, latitude: 40.733 },
+                    { longitude: -73.979, latitude: 40.743 }
                 ],
                 routing_profile: 'driving',
                 exclude: 'toll,motorway,unpaved'
@@ -207,8 +339,8 @@ describe('DirectionsTool', () => {
             // Test with driving-traffic profile
             await expect(tool.run({
                 coordinates: [
-                    [-73.989, 40.733],
-                    [-73.979, 40.743]
+                    { longitude: -73.989, latitude: 40.733 },
+                    { longitude: -73.979, latitude: 40.743 }
                 ],
                 routing_profile: 'driving-traffic',
                 exclude: 'tunnel,country_border,state_border'
@@ -221,8 +353,8 @@ describe('DirectionsTool', () => {
             // Test with walking profile
             await expect(tool.run({
                 coordinates: [
-                    [-73.989, 40.733],
-                    [-73.979, 40.743]
+                    { longitude: -73.989, latitude: 40.733 },
+                    { longitude: -73.979, latitude: 40.743 }
                 ],
                 routing_profile: 'walking',
                 exclude: 'toll'
@@ -232,8 +364,8 @@ describe('DirectionsTool', () => {
             // Test with cycling profile
             await expect(tool.run({
                 coordinates: [
-                    [-73.989, 40.733],
-                    [-73.979, 40.743]
+                    { longitude: -73.989, latitude: 40.733 },
+                    { longitude: -73.979, latitude: 40.743 }
                 ],
                 routing_profile: 'cycling',
                 exclude: 'motorway'
@@ -247,8 +379,8 @@ describe('DirectionsTool', () => {
             // Test with driving profile
             await expect(tool.run({
                 coordinates: [
-                    [-73.989, 40.733],
-                    [-73.979, 40.743]
+                    { longitude: -73.989, latitude: 40.733 },
+                    { longitude: -73.979, latitude: 40.743 }
                 ],
                 routing_profile: 'driving',
                 exclude: 'ferry'
@@ -258,8 +390,8 @@ describe('DirectionsTool', () => {
             // Test with walking profile
             await expect(tool.run({
                 coordinates: [
-                    [-73.989, 40.733],
-                    [-73.979, 40.743]
+                    { longitude: -73.989, latitude: 40.733 },
+                    { longitude: -73.979, latitude: 40.743 }
                 ],
                 routing_profile: 'walking',
                 exclude: 'ferry'
@@ -269,8 +401,8 @@ describe('DirectionsTool', () => {
             // Test with cycling profile
             await expect(tool.run({
                 coordinates: [
-                    [-73.989, 40.733],
-                    [-73.979, 40.743]
+                    { longitude: -73.989, latitude: 40.733 },
+                    { longitude: -73.979, latitude: 40.743 }
                 ],
                 routing_profile: 'cycling',
                 exclude: 'cash_only_tolls'
@@ -284,8 +416,8 @@ describe('DirectionsTool', () => {
             // Test with driving profile - should work
             await expect(tool.run({
                 coordinates: [
-                    [-73.989, 40.733],
-                    [-73.979, 40.743]
+                    { longitude: -73.989, latitude: 40.733 },
+                    { longitude: -73.979, latitude: 40.743 }
                 ],
                 routing_profile: 'driving',
                 exclude: 'point(-73.95 40.75)'
@@ -295,8 +427,8 @@ describe('DirectionsTool', () => {
             // Test with walking profile - should fail
             await expect(tool.run({
                 coordinates: [
-                    [-73.989, 40.733],
-                    [-73.979, 40.743]
+                    { longitude: -73.989, latitude: 40.733 },
+                    { longitude: -73.979, latitude: 40.743 }
                 ],
                 routing_profile: 'walking',
                 exclude: 'point(-73.95 40.75)'
@@ -306,8 +438,8 @@ describe('DirectionsTool', () => {
             // Test with cycling profile - should fail
             await expect(tool.run({
                 coordinates: [
-                    [-73.989, 40.733],
-                    [-73.979, 40.743]
+                    { longitude: -73.989, latitude: 40.733 },
+                    { longitude: -73.979, latitude: 40.743 }
                 ],
                 routing_profile: 'cycling',
                 exclude: 'point(-73.95 40.75)'
@@ -321,8 +453,8 @@ describe('DirectionsTool', () => {
             // All valid exclusions for driving profile
             await expect(tool.run({
                 coordinates: [
-                    [-73.989, 40.733],
-                    [-73.979, 40.743]
+                    { longitude: -73.989, latitude: 40.733 },
+                    { longitude: -73.979, latitude: 40.743 }
                 ],
                 routing_profile: 'driving',
                 exclude: 'toll,motorway,ferry,cash_only_tolls,point(-73.95 40.75)'
@@ -332,8 +464,8 @@ describe('DirectionsTool', () => {
             // Mixed valid and invalid exclusions (ferry is valid for walking, toll is not)
             await expect(tool.run({
                 coordinates: [
-                    [-73.989, 40.733],
-                    [-73.979, 40.743]
+                    { longitude: -73.989, latitude: 40.733 },
+                    { longitude: -73.979, latitude: 40.743 }
                 ],
                 routing_profile: 'walking',
                 exclude: 'ferry,toll'
@@ -343,8 +475,8 @@ describe('DirectionsTool', () => {
             // All valid exclusions for cycling profile
             await expect(tool.run({
                 coordinates: [
-                    [-73.989, 40.733],
-                    [-73.979, 40.743]
+                    { longitude: -73.989, latitude: 40.733 },
+                    { longitude: -73.979, latitude: 40.743 }
                 ],
                 routing_profile: 'cycling',
                 exclude: 'ferry,cash_only_tolls'
@@ -361,8 +493,8 @@ describe('DirectionsTool', () => {
             // Test with driving profile
             await expect(tool.run({
                 coordinates: [
-                    [-73.989, 40.733],
-                    [-73.979, 40.743]
+                    { longitude: -73.989, latitude: 40.733 },
+                    { longitude: -73.979, latitude: 40.743 }
                 ],
                 routing_profile: 'driving',
                 depart_at: validDateTime
@@ -374,8 +506,8 @@ describe('DirectionsTool', () => {
             // Test with driving-traffic profile
             await expect(tool.run({
                 coordinates: [
-                    [-73.989, 40.733],
-                    [-73.979, 40.743]
+                    { longitude: -73.989, latitude: 40.733 },
+                    { longitude: -73.979, latitude: 40.743 }
                 ],
                 routing_profile: 'driving-traffic',
                 depart_at: validDateTime
@@ -392,8 +524,8 @@ describe('DirectionsTool', () => {
                 // Test with driving profile
                 await expect(tool.run({
                     coordinates: [
-                        [-73.989, 40.733],
-                        [-73.979, 40.743]
+                        { longitude: -73.989, latitude: 40.733 },
+                        { longitude: -73.979, latitude: 40.743 }
                     ],
                     routing_profile: 'driving',
                     max_height: 4.5,
@@ -409,8 +541,8 @@ describe('DirectionsTool', () => {
                 // Test with driving-traffic profile
                 await expect(tool.run({
                     coordinates: [
-                        [-73.989, 40.733],
-                        [-73.979, 40.743]
+                        { longitude: -73.989, latitude: 40.733 },
+                        { longitude: -73.979, latitude: 40.743 }
                     ],
                     routing_profile: 'driving-traffic',
                     max_height: 3.2
@@ -425,8 +557,8 @@ describe('DirectionsTool', () => {
                 // Test with walking profile
                 await expect(tool.run({
                     coordinates: [
-                        [-73.989, 40.733],
-                        [-73.979, 40.743]
+                        { longitude: -73.989, latitude: 40.733 },
+                        { longitude: -73.979, latitude: 40.743 }
                     ],
                     routing_profile: 'walking',
                     max_height: 4.5
@@ -436,8 +568,8 @@ describe('DirectionsTool', () => {
                 // Test with cycling profile
                 await expect(tool.run({
                     coordinates: [
-                        [-73.989, 40.733],
-                        [-73.979, 40.743]
+                        { longitude: -73.989, latitude: 40.733 },
+                        { longitude: -73.979, latitude: 40.743 }
                     ],
                     routing_profile: 'cycling',
                     max_width: 2.0
@@ -450,8 +582,8 @@ describe('DirectionsTool', () => {
                 // Test invalid height (too high)
                 await expect(tool.run({
                     coordinates: [
-                        [-73.989, 40.733],
-                        [-73.979, 40.743]
+                        { longitude: -73.989, latitude: 40.733 },
+                        { longitude: -73.979, latitude: 40.743 }
                     ],
                     routing_profile: 'driving',
                     max_height: 15.0
@@ -461,8 +593,8 @@ describe('DirectionsTool', () => {
                 // Test invalid width (negative)
                 await expect(tool.run({
                     coordinates: [
-                        [-73.989, 40.733],
-                        [-73.979, 40.743]
+                        { longitude: -73.989, latitude: 40.733 },
+                        { longitude: -73.979, latitude: 40.743 }
                     ],
                     routing_profile: 'driving',
                     max_width: -1.0
@@ -472,8 +604,8 @@ describe('DirectionsTool', () => {
                 // Test invalid weight (too heavy)
                 await expect(tool.run({
                     coordinates: [
-                        [-73.989, 40.733],
-                        [-73.979, 40.743]
+                        { longitude: -73.989, latitude: 40.733 },
+                        { longitude: -73.979, latitude: 40.743 }
                     ],
                     routing_profile: 'driving',
                     max_weight: 150.0
@@ -488,8 +620,8 @@ describe('DirectionsTool', () => {
             // Test with walking profile
             await expect(tool.run({
                 coordinates: [
-                    [-73.989, 40.733],
-                    [-73.979, 40.743]
+                    { longitude: -73.989, latitude: 40.733 },
+                    { longitude: -73.979, latitude: 40.743 }
                 ],
                 routing_profile: 'walking',
                 depart_at: validDateTime
@@ -499,8 +631,8 @@ describe('DirectionsTool', () => {
             // Test with cycling profile
             await expect(tool.run({
                 coordinates: [
-                    [-73.989, 40.733],
-                    [-73.979, 40.743]
+                    { longitude: -73.989, latitude: 40.733 },
+                    { longitude: -73.979, latitude: 40.743 }
                 ],
                 routing_profile: 'cycling',
                 depart_at: validDateTime
@@ -512,8 +644,8 @@ describe('DirectionsTool', () => {
             const mockFetch = setupFetch();
             const tool = new DirectionsTool();
             const baseCoordinates = [
-                [-73.989, 40.733],
-                [-73.979, 40.743]
+                { longitude: -73.989, latitude: 40.733 },
+                { longitude: -73.979, latitude: 40.743 }
             ];
             // Format 1: YYYY-MM-DDThh:mm:ssZ
             await expect(tool.run({
@@ -540,8 +672,8 @@ describe('DirectionsTool', () => {
         it('rejects invalid date-time formats', async () => {
             const tool = new DirectionsTool();
             const baseCoordinates = [
-                [-73.989, 40.733],
-                [-73.979, 40.743]
+                { longitude: -73.989, latitude: 40.733 },
+                { longitude: -73.979, latitude: 40.743 }
             ];
             // Invalid format examples
             const invalidFormats = [
@@ -567,8 +699,8 @@ describe('DirectionsTool', () => {
         it('rejects dates with invalid components', async () => {
             const tool = new DirectionsTool();
             const baseCoordinates = [
-                [-73.989, 40.733],
-                [-73.979, 40.743]
+                { longitude: -73.989, latitude: 40.733 },
+                { longitude: -73.979, latitude: 40.743 }
             ];
             // Invalid time components
             const invalidDates = [
@@ -587,45 +719,6 @@ describe('DirectionsTool', () => {
                 });
             }
         });
-        it('depart_at accepts and converts YYYY-MM-DDThh:mm:ss format (seconds but no timezone)', async () => {
-            const mockFetch = setupFetch();
-            const tool = new DirectionsTool();
-            const dateTimeWithSeconds = '2025-06-05T10:30:45';
-            const expectedConvertedDateTime = '2025-06-05T10:30'; // Without seconds
-            await expect(tool.run({
-                coordinates: [
-                    [-73.989, 40.733],
-                    [-73.979, 40.743]
-                ],
-                depart_at: dateTimeWithSeconds
-            })).resolves.not.toMatchObject({
-                is_error: true
-            });
-            // Verify the seconds were stripped in the API call
-            const calledUrl = mockFetch.mock.calls[0][0];
-            expect(calledUrl).toContain(`depart_at=${encodeURIComponent(expectedConvertedDateTime)}`);
-            expect(calledUrl).not.toContain(`depart_at=${encodeURIComponent(dateTimeWithSeconds)}`);
-        });
-        it('arrive_by accepts and converts YYYY-MM-DDThh:mm:ss format (seconds but no timezone)', async () => {
-            const mockFetch = setupFetch();
-            const tool = new DirectionsTool();
-            const dateTimeWithSeconds = '2025-06-05T10:30:45';
-            const expectedConvertedDateTime = '2025-06-05T10:30'; // Without seconds
-            await expect(tool.run({
-                coordinates: [
-                    [-73.989, 40.733],
-                    [-73.979, 40.743]
-                ],
-                routing_profile: 'driving',
-                arrive_by: dateTimeWithSeconds
-            })).resolves.not.toMatchObject({
-                is_error: true
-            });
-            // Verify the seconds were stripped in the API call
-            const calledUrl = mockFetch.mock.calls[0][0];
-            expect(calledUrl).toContain(`arrive_by=${encodeURIComponent(expectedConvertedDateTime)}`);
-            expect(calledUrl).not.toContain(`arrive_by=${encodeURIComponent(dateTimeWithSeconds)}`);
-        });
     });
     describe('arrive_by parameter validations', () => {
         it('accepts arrive_by with driving profile only', async () => {
@@ -634,8 +727,8 @@ describe('DirectionsTool', () => {
             // Test with driving profile - should work
             await new DirectionsTool().run({
                 coordinates: [
-                    [-74.1, 40.7],
-                    [-74.2, 40.8]
+                    { longitude: -74.1, latitude: 40.7 },
+                    { longitude: -74.2, latitude: 40.8 }
                 ],
                 routing_profile: 'driving',
                 arrive_by: validDateTime
@@ -649,8 +742,8 @@ describe('DirectionsTool', () => {
             // Test with driving-traffic profile
             const result1 = await new DirectionsTool().run({
                 coordinates: [
-                    [-74.1, 40.7],
-                    [-74.2, 40.8]
+                    { longitude: -74.1, latitude: 40.7 },
+                    { longitude: -74.2, latitude: 40.8 }
                 ],
                 routing_profile: 'driving-traffic',
                 arrive_by: validDateTime
@@ -659,8 +752,8 @@ describe('DirectionsTool', () => {
             // Test with walking profile
             const result2 = await new DirectionsTool().run({
                 coordinates: [
-                    [-74.1, 40.7],
-                    [-74.2, 40.8]
+                    { longitude: -74.1, latitude: 40.7 },
+                    { longitude: -74.2, latitude: 40.8 }
                 ],
                 routing_profile: 'walking',
                 arrive_by: validDateTime
@@ -669,8 +762,8 @@ describe('DirectionsTool', () => {
             // Test with cycling profile
             const result3 = await new DirectionsTool().run({
                 coordinates: [
-                    [-74.1, 40.7],
-                    [-74.2, 40.8]
+                    { longitude: -74.1, latitude: 40.7 },
+                    { longitude: -74.2, latitude: 40.8 }
                 ],
                 routing_profile: 'cycling',
                 arrive_by: validDateTime
@@ -680,8 +773,8 @@ describe('DirectionsTool', () => {
         it('rejects when both arrive_by and depart_at are provided', async () => {
             const result = await new DirectionsTool().run({
                 coordinates: [
-                    [-74.1, 40.7],
-                    [-74.2, 40.8]
+                    { longitude: -74.1, latitude: 40.7 },
+                    { longitude: -74.2, latitude: 40.8 }
                 ],
                 routing_profile: 'driving',
                 depart_at: '2025-06-05T09:30:00Z',
@@ -694,8 +787,8 @@ describe('DirectionsTool', () => {
             // Test with Z format
             await new DirectionsTool().run({
                 coordinates: [
-                    [-74.1, 40.7],
-                    [-74.2, 40.8]
+                    { longitude: -74.1, latitude: 40.7 },
+                    { longitude: -74.2, latitude: 40.8 }
                 ],
                 routing_profile: 'driving',
                 arrive_by: '2025-06-05T10:30:00Z'
@@ -705,8 +798,8 @@ describe('DirectionsTool', () => {
             // Test with timezone offset format
             await new DirectionsTool().run({
                 coordinates: [
-                    [-74.1, 40.7],
-                    [-74.2, 40.8]
+                    { longitude: -74.1, latitude: 40.7 },
+                    { longitude: -74.2, latitude: 40.8 }
                 ],
                 routing_profile: 'driving',
                 arrive_by: '2025-06-05T10:30:00+02:00'
@@ -716,8 +809,8 @@ describe('DirectionsTool', () => {
             // Test with simple time format (no seconds, no timezone)
             await new DirectionsTool().run({
                 coordinates: [
-                    [-74.1, 40.7],
-                    [-74.2, 40.8]
+                    { longitude: -74.1, latitude: 40.7 },
+                    { longitude: -74.2, latitude: 40.8 }
                 ],
                 routing_profile: 'driving',
                 arrive_by: '2025-06-05T10:30'
@@ -743,8 +836,8 @@ describe('DirectionsTool', () => {
             for (const format of invalidFormats) {
                 const result = await new DirectionsTool().run({
                     coordinates: [
-                        [-74.1, 40.7],
-                        [-74.2, 40.8]
+                        { longitude: -74.1, latitude: 40.7 },
+                        { longitude: -74.2, latitude: 40.8 }
                     ],
                     routing_profile: 'driving',
                     arrive_by: format
@@ -764,8 +857,8 @@ describe('DirectionsTool', () => {
             for (const date of invalidDates) {
                 const result = await new DirectionsTool().run({
                     coordinates: [
-                        [-74.1, 40.7],
-                        [-74.2, 40.8]
+                        { longitude: -74.1, latitude: 40.7 },
+                        { longitude: -74.2, latitude: 40.8 }
                     ],
                     routing_profile: 'driving',
                     arrive_by: date
@@ -774,49 +867,5 @@ describe('DirectionsTool', () => {
             }
         });
     });
-    it('validates geometries enum values', async () => {
-        const tool = new DirectionsTool();
-        // Valid values: 'none' and 'geojson'
-        await expect(tool.run({
-            coordinates: [
-                [-73.989, 40.733],
-                [-73.979, 40.743]
-            ],
-            geometries: 'none'
-        })).resolves.not.toMatchObject({
-            is_error: true
-        });
-        await expect(tool.run({
-            coordinates: [
-                [-73.989, 40.733],
-                [-73.979, 40.743]
-            ],
-            geometries: 'geojson'
-        })).resolves.not.toMatchObject({
-            is_error: true
-        });
-        // Invalid values: 'polyline' and 'polyline6' were removed
-        // Test with invalid string values (runtime validation)
-        await expect(tool.run({
-            coordinates: [
-                [-73.989, 40.733],
-                [-73.979, 40.743]
-            ],
-            // @ts-ignore - Testing with invalid value for runtime validation
-            geometries: 'polyline'
-        })).resolves.toMatchObject({
-            is_error: true
-        });
-        await expect(tool.run({
-            coordinates: [
-                [-73.989, 40.733],
-                [-73.979, 40.743]
-            ],
-            // @ts-ignore - Testing with invalid value for runtime validation
-            geometries: 'polyline6'
-        })).resolves.toMatchObject({
-            is_error: true
-        });
-    });
 });
 //# sourceMappingURL=DirectionsTool.test.js.map