@mapbox/mcp-server 0.2.1-dev.3 → 0.2.2

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

@@ -1,9 +1,18 @@
-process.env.MAPBOX_ACCESS_TOKEN =
-    'eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiJ0ZXN0In0.signature';
+process.env.MAPBOX_ACCESS_TOKEN = 'test.token.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();
@@ -12,8 +21,8 @@ describe('DirectionsTool', () => {
         const mockFetch = setupFetch();
         await new DirectionsTool().run({
             coordinates: [
-                { longitude: -74.102094, latitude: 40.692815 },
-                { longitude: -74.1022094, latitude: 40.792815 }
+                [-74.102094, 40.692815],
+                [-74.1022094, 40.792815]
             ]
         });
         assertHeadersSent(mockFetch);
@@ -22,8 +31,8 @@ describe('DirectionsTool', () => {
         const mockFetch = setupFetch();
         await new DirectionsTool().run({
             coordinates: [
-                { longitude: -73.989, latitude: 40.733 },
-                { longitude: -73.979, latitude: 40.743 }
+                [-73.989, 40.733],
+                [-73.979, 40.743]
             ]
         });
         const calledUrl = mockFetch.mock.calls[0][0];
@@ -36,14 +45,13 @@ describe('DirectionsTool', () => {
         const mockFetch = setupFetch();
         await new DirectionsTool().run({
             coordinates: [
-                { longitude: -122.42, latitude: 37.78 },
-                { longitude: -122.4, latitude: 37.79 },
-                { longitude: -122.39, latitude: 37.77 }
+                [-122.42, 37.78],
+                [-122.4, 37.79],
+                [-122.39, 37.77]
             ],
             routing_profile: 'walking',
             geometries: 'geojson',
             alternatives: true,
-            annotations: ['distance', 'duration', 'speed'],
             exclude: 'ferry'
         });
         const calledUrl = mockFetch.mock.calls[0][0];
@@ -51,7 +59,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%2Cduration%2Cspeed');
+        expect(calledUrl).toContain('annotations=distance%2Cspeed');
         expect(calledUrl).toContain('overview=full');
         expect(calledUrl).toContain('exclude=ferry');
         assertHeadersSent(mockFetch);
@@ -60,15 +68,32 @@ describe('DirectionsTool', () => {
         const mockFetch = setupFetch();
         await new DirectionsTool().run({
             coordinates: [
-                { longitude: -118.24, latitude: 34.05 },
-                { longitude: -118.3, latitude: 34.02 }
+                [-118.24, 34.05],
+                [-118.3, 34.02]
             ]
         });
         const calledUrl = mockFetch.mock.calls[0][0];
         expect(calledUrl).toContain('directions/v5/mapbox/driving-traffic');
-        expect(calledUrl).toContain('geometries=polyline');
+        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('alternatives=false');
-        expect(calledUrl).not.toContain('annotations=');
+        expect(calledUrl).toContain('annotations=distance%2Ccongestion%2Cspeed');
         expect(calledUrl).not.toContain('exclude=');
         assertHeadersSent(mockFetch);
     });
@@ -76,8 +101,8 @@ describe('DirectionsTool', () => {
         const mockFetch = setupFetch();
         await new DirectionsTool().run({
             coordinates: [
-                { longitude: -74.0, latitude: 40.7 },
-                { longitude: -73.9, latitude: 40.8 }
+                [-74.0, 40.7],
+                [-73.9, 40.8]
             ],
             exclude: 'toll,point(-73.95 40.75)'
         });
@@ -97,14 +122,14 @@ describe('DirectionsTool', () => {
         });
         const result = await new DirectionsTool().run({
             coordinates: [
-                { longitude: -73.989, latitude: 40.733 },
-                { longitude: -73.979, latitude: 40.743 }
+                [-73.989, 40.733],
+                [-73.979, 40.743]
             ]
         });
         expect(result.is_error).toBe(true);
         expect(result.content[0]).toMatchObject({
             type: 'text',
-            text: 'Internal error has occurred.'
+            text: 'Request failed with status 404: Not Found'
         });
         assertHeadersSent(mockFetch);
     });
@@ -112,7 +137,7 @@ describe('DirectionsTool', () => {
         const tool = new DirectionsTool();
         // Test with only one coordinate (invalid)
         await expect(tool.run({
-            coordinates: [{ longitude: -73.989, latitude: 40.733 }]
+            coordinates: [[-73.989, 40.733]]
         })).resolves.toMatchObject({
             is_error: true
         });
@@ -126,10 +151,7 @@ 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({
-            longitude: -73.989,
-            latitude: 40.733
-        });
+        const tooManyCoords = Array(26).fill([-73.989, 40.733]);
         await expect(tool.run({
             coordinates: tooManyCoords
         })).resolves.toMatchObject({
@@ -140,8 +162,8 @@ describe('DirectionsTool', () => {
         const mockFetch = setupFetch();
         await new DirectionsTool().run({
             coordinates: [
-                { longitude: -73.989, latitude: 40.733 },
-                { longitude: -73.979, latitude: 40.743 }
+                [-73.989, 40.733],
+                [-73.979, 40.743]
             ]
         });
         const calledUrl = mockFetch.mock.calls[0][0];
@@ -153,174 +175,20 @@ describe('DirectionsTool', () => {
         // Create an array of exactly 25 coordinates (maximum allowed)
         const maxCoords = Array(25)
             .fill(0)
-            .map((_, i) => ({ longitude: -74 + i * 0.01, latitude: 40 + i * 0.01 }));
+            .map((_, i) => [-74 + i * 0.01, 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 { longitude: lng, latitude: lat } = maxCoords[i];
+            const [lng, 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();
@@ -328,8 +196,8 @@ describe('DirectionsTool', () => {
             // Test with driving profile
             await expect(tool.run({
                 coordinates: [
-                    { longitude: -73.989, latitude: 40.733 },
-                    { longitude: -73.979, latitude: 40.743 }
+                    [-73.989, 40.733],
+                    [-73.979, 40.743]
                 ],
                 routing_profile: 'driving',
                 exclude: 'toll,motorway,unpaved'
@@ -339,8 +207,8 @@ describe('DirectionsTool', () => {
             // Test with driving-traffic profile
             await expect(tool.run({
                 coordinates: [
-                    { longitude: -73.989, latitude: 40.733 },
-                    { longitude: -73.979, latitude: 40.743 }
+                    [-73.989, 40.733],
+                    [-73.979, 40.743]
                 ],
                 routing_profile: 'driving-traffic',
                 exclude: 'tunnel,country_border,state_border'
@@ -353,8 +221,8 @@ describe('DirectionsTool', () => {
             // Test with walking profile
             await expect(tool.run({
                 coordinates: [
-                    { longitude: -73.989, latitude: 40.733 },
-                    { longitude: -73.979, latitude: 40.743 }
+                    [-73.989, 40.733],
+                    [-73.979, 40.743]
                 ],
                 routing_profile: 'walking',
                 exclude: 'toll'
@@ -364,8 +232,8 @@ describe('DirectionsTool', () => {
             // Test with cycling profile
             await expect(tool.run({
                 coordinates: [
-                    { longitude: -73.989, latitude: 40.733 },
-                    { longitude: -73.979, latitude: 40.743 }
+                    [-73.989, 40.733],
+                    [-73.979, 40.743]
                 ],
                 routing_profile: 'cycling',
                 exclude: 'motorway'
@@ -379,8 +247,8 @@ describe('DirectionsTool', () => {
             // Test with driving profile
             await expect(tool.run({
                 coordinates: [
-                    { longitude: -73.989, latitude: 40.733 },
-                    { longitude: -73.979, latitude: 40.743 }
+                    [-73.989, 40.733],
+                    [-73.979, 40.743]
                 ],
                 routing_profile: 'driving',
                 exclude: 'ferry'
@@ -390,8 +258,8 @@ describe('DirectionsTool', () => {
             // Test with walking profile
             await expect(tool.run({
                 coordinates: [
-                    { longitude: -73.989, latitude: 40.733 },
-                    { longitude: -73.979, latitude: 40.743 }
+                    [-73.989, 40.733],
+                    [-73.979, 40.743]
                 ],
                 routing_profile: 'walking',
                 exclude: 'ferry'
@@ -401,8 +269,8 @@ describe('DirectionsTool', () => {
             // Test with cycling profile
             await expect(tool.run({
                 coordinates: [
-                    { longitude: -73.989, latitude: 40.733 },
-                    { longitude: -73.979, latitude: 40.743 }
+                    [-73.989, 40.733],
+                    [-73.979, 40.743]
                 ],
                 routing_profile: 'cycling',
                 exclude: 'cash_only_tolls'
@@ -416,8 +284,8 @@ describe('DirectionsTool', () => {
             // Test with driving profile - should work
             await expect(tool.run({
                 coordinates: [
-                    { longitude: -73.989, latitude: 40.733 },
-                    { longitude: -73.979, latitude: 40.743 }
+                    [-73.989, 40.733],
+                    [-73.979, 40.743]
                 ],
                 routing_profile: 'driving',
                 exclude: 'point(-73.95 40.75)'
@@ -427,8 +295,8 @@ describe('DirectionsTool', () => {
             // Test with walking profile - should fail
             await expect(tool.run({
                 coordinates: [
-                    { longitude: -73.989, latitude: 40.733 },
-                    { longitude: -73.979, latitude: 40.743 }
+                    [-73.989, 40.733],
+                    [-73.979, 40.743]
                 ],
                 routing_profile: 'walking',
                 exclude: 'point(-73.95 40.75)'
@@ -438,8 +306,8 @@ describe('DirectionsTool', () => {
             // Test with cycling profile - should fail
             await expect(tool.run({
                 coordinates: [
-                    { longitude: -73.989, latitude: 40.733 },
-                    { longitude: -73.979, latitude: 40.743 }
+                    [-73.989, 40.733],
+                    [-73.979, 40.743]
                 ],
                 routing_profile: 'cycling',
                 exclude: 'point(-73.95 40.75)'
@@ -453,8 +321,8 @@ describe('DirectionsTool', () => {
             // All valid exclusions for driving profile
             await expect(tool.run({
                 coordinates: [
-                    { longitude: -73.989, latitude: 40.733 },
-                    { longitude: -73.979, latitude: 40.743 }
+                    [-73.989, 40.733],
+                    [-73.979, 40.743]
                 ],
                 routing_profile: 'driving',
                 exclude: 'toll,motorway,ferry,cash_only_tolls,point(-73.95 40.75)'
@@ -464,8 +332,8 @@ describe('DirectionsTool', () => {
             // Mixed valid and invalid exclusions (ferry is valid for walking, toll is not)
             await expect(tool.run({
                 coordinates: [
-                    { longitude: -73.989, latitude: 40.733 },
-                    { longitude: -73.979, latitude: 40.743 }
+                    [-73.989, 40.733],
+                    [-73.979, 40.743]
                 ],
                 routing_profile: 'walking',
                 exclude: 'ferry,toll'
@@ -475,8 +343,8 @@ describe('DirectionsTool', () => {
             // All valid exclusions for cycling profile
             await expect(tool.run({
                 coordinates: [
-                    { longitude: -73.989, latitude: 40.733 },
-                    { longitude: -73.979, latitude: 40.743 }
+                    [-73.989, 40.733],
+                    [-73.979, 40.743]
                 ],
                 routing_profile: 'cycling',
                 exclude: 'ferry,cash_only_tolls'
@@ -493,8 +361,8 @@ describe('DirectionsTool', () => {
             // Test with driving profile
             await expect(tool.run({
                 coordinates: [
-                    { longitude: -73.989, latitude: 40.733 },
-                    { longitude: -73.979, latitude: 40.743 }
+                    [-73.989, 40.733],
+                    [-73.979, 40.743]
                 ],
                 routing_profile: 'driving',
                 depart_at: validDateTime
@@ -506,8 +374,8 @@ describe('DirectionsTool', () => {
             // Test with driving-traffic profile
             await expect(tool.run({
                 coordinates: [
-                    { longitude: -73.989, latitude: 40.733 },
-                    { longitude: -73.979, latitude: 40.743 }
+                    [-73.989, 40.733],
+                    [-73.979, 40.743]
                 ],
                 routing_profile: 'driving-traffic',
                 depart_at: validDateTime
@@ -524,8 +392,8 @@ describe('DirectionsTool', () => {
                 // Test with driving profile
                 await expect(tool.run({
                     coordinates: [
-                        { longitude: -73.989, latitude: 40.733 },
-                        { longitude: -73.979, latitude: 40.743 }
+                        [-73.989, 40.733],
+                        [-73.979, 40.743]
                     ],
                     routing_profile: 'driving',
                     max_height: 4.5,
@@ -541,8 +409,8 @@ describe('DirectionsTool', () => {
                 // Test with driving-traffic profile
                 await expect(tool.run({
                     coordinates: [
-                        { longitude: -73.989, latitude: 40.733 },
-                        { longitude: -73.979, latitude: 40.743 }
+                        [-73.989, 40.733],
+                        [-73.979, 40.743]
                     ],
                     routing_profile: 'driving-traffic',
                     max_height: 3.2
@@ -557,8 +425,8 @@ describe('DirectionsTool', () => {
                 // Test with walking profile
                 await expect(tool.run({
                     coordinates: [
-                        { longitude: -73.989, latitude: 40.733 },
-                        { longitude: -73.979, latitude: 40.743 }
+                        [-73.989, 40.733],
+                        [-73.979, 40.743]
                     ],
                     routing_profile: 'walking',
                     max_height: 4.5
@@ -568,8 +436,8 @@ describe('DirectionsTool', () => {
                 // Test with cycling profile
                 await expect(tool.run({
                     coordinates: [
-                        { longitude: -73.989, latitude: 40.733 },
-                        { longitude: -73.979, latitude: 40.743 }
+                        [-73.989, 40.733],
+                        [-73.979, 40.743]
                     ],
                     routing_profile: 'cycling',
                     max_width: 2.0
@@ -582,8 +450,8 @@ describe('DirectionsTool', () => {
                 // Test invalid height (too high)
                 await expect(tool.run({
                     coordinates: [
-                        { longitude: -73.989, latitude: 40.733 },
-                        { longitude: -73.979, latitude: 40.743 }
+                        [-73.989, 40.733],
+                        [-73.979, 40.743]
                     ],
                     routing_profile: 'driving',
                     max_height: 15.0
@@ -593,8 +461,8 @@ describe('DirectionsTool', () => {
                 // Test invalid width (negative)
                 await expect(tool.run({
                     coordinates: [
-                        { longitude: -73.989, latitude: 40.733 },
-                        { longitude: -73.979, latitude: 40.743 }
+                        [-73.989, 40.733],
+                        [-73.979, 40.743]
                     ],
                     routing_profile: 'driving',
                     max_width: -1.0
@@ -604,8 +472,8 @@ describe('DirectionsTool', () => {
                 // Test invalid weight (too heavy)
                 await expect(tool.run({
                     coordinates: [
-                        { longitude: -73.989, latitude: 40.733 },
-                        { longitude: -73.979, latitude: 40.743 }
+                        [-73.989, 40.733],
+                        [-73.979, 40.743]
                     ],
                     routing_profile: 'driving',
                     max_weight: 150.0
@@ -620,8 +488,8 @@ describe('DirectionsTool', () => {
             // Test with walking profile
             await expect(tool.run({
                 coordinates: [
-                    { longitude: -73.989, latitude: 40.733 },
-                    { longitude: -73.979, latitude: 40.743 }
+                    [-73.989, 40.733],
+                    [-73.979, 40.743]
                 ],
                 routing_profile: 'walking',
                 depart_at: validDateTime
@@ -631,8 +499,8 @@ describe('DirectionsTool', () => {
             // Test with cycling profile
             await expect(tool.run({
                 coordinates: [
-                    { longitude: -73.989, latitude: 40.733 },
-                    { longitude: -73.979, latitude: 40.743 }
+                    [-73.989, 40.733],
+                    [-73.979, 40.743]
                 ],
                 routing_profile: 'cycling',
                 depart_at: validDateTime
@@ -644,8 +512,8 @@ describe('DirectionsTool', () => {
             const mockFetch = setupFetch();
             const tool = new DirectionsTool();
             const baseCoordinates = [
-                { longitude: -73.989, latitude: 40.733 },
-                { longitude: -73.979, latitude: 40.743 }
+                [-73.989, 40.733],
+                [-73.979, 40.743]
             ];
             // Format 1: YYYY-MM-DDThh:mm:ssZ
             await expect(tool.run({
@@ -672,8 +540,8 @@ describe('DirectionsTool', () => {
         it('rejects invalid date-time formats', async () => {
             const tool = new DirectionsTool();
             const baseCoordinates = [
-                { longitude: -73.989, latitude: 40.733 },
-                { longitude: -73.979, latitude: 40.743 }
+                [-73.989, 40.733],
+                [-73.979, 40.743]
             ];
             // Invalid format examples
             const invalidFormats = [
@@ -699,8 +567,8 @@ describe('DirectionsTool', () => {
         it('rejects dates with invalid components', async () => {
             const tool = new DirectionsTool();
             const baseCoordinates = [
-                { longitude: -73.989, latitude: 40.733 },
-                { longitude: -73.979, latitude: 40.743 }
+                [-73.989, 40.733],
+                [-73.979, 40.743]
             ];
             // Invalid time components
             const invalidDates = [
@@ -719,6 +587,45 @@ 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 () => {
@@ -727,8 +634,8 @@ describe('DirectionsTool', () => {
             // Test with driving profile - should work
             await new DirectionsTool().run({
                 coordinates: [
-                    { longitude: -74.1, latitude: 40.7 },
-                    { longitude: -74.2, latitude: 40.8 }
+                    [-74.1, 40.7],
+                    [-74.2, 40.8]
                 ],
                 routing_profile: 'driving',
                 arrive_by: validDateTime
@@ -742,8 +649,8 @@ describe('DirectionsTool', () => {
             // Test with driving-traffic profile
             const result1 = await new DirectionsTool().run({
                 coordinates: [
-                    { longitude: -74.1, latitude: 40.7 },
-                    { longitude: -74.2, latitude: 40.8 }
+                    [-74.1, 40.7],
+                    [-74.2, 40.8]
                 ],
                 routing_profile: 'driving-traffic',
                 arrive_by: validDateTime
@@ -752,8 +659,8 @@ describe('DirectionsTool', () => {
             // Test with walking profile
             const result2 = await new DirectionsTool().run({
                 coordinates: [
-                    { longitude: -74.1, latitude: 40.7 },
-                    { longitude: -74.2, latitude: 40.8 }
+                    [-74.1, 40.7],
+                    [-74.2, 40.8]
                 ],
                 routing_profile: 'walking',
                 arrive_by: validDateTime
@@ -762,8 +669,8 @@ describe('DirectionsTool', () => {
             // Test with cycling profile
             const result3 = await new DirectionsTool().run({
                 coordinates: [
-                    { longitude: -74.1, latitude: 40.7 },
-                    { longitude: -74.2, latitude: 40.8 }
+                    [-74.1, 40.7],
+                    [-74.2, 40.8]
                 ],
                 routing_profile: 'cycling',
                 arrive_by: validDateTime
@@ -773,8 +680,8 @@ describe('DirectionsTool', () => {
         it('rejects when both arrive_by and depart_at are provided', async () => {
             const result = await new DirectionsTool().run({
                 coordinates: [
-                    { longitude: -74.1, latitude: 40.7 },
-                    { longitude: -74.2, latitude: 40.8 }
+                    [-74.1, 40.7],
+                    [-74.2, 40.8]
                 ],
                 routing_profile: 'driving',
                 depart_at: '2025-06-05T09:30:00Z',
@@ -787,8 +694,8 @@ describe('DirectionsTool', () => {
             // Test with Z format
             await new DirectionsTool().run({
                 coordinates: [
-                    { longitude: -74.1, latitude: 40.7 },
-                    { longitude: -74.2, latitude: 40.8 }
+                    [-74.1, 40.7],
+                    [-74.2, 40.8]
                 ],
                 routing_profile: 'driving',
                 arrive_by: '2025-06-05T10:30:00Z'
@@ -798,8 +705,8 @@ describe('DirectionsTool', () => {
             // Test with timezone offset format
             await new DirectionsTool().run({
                 coordinates: [
-                    { longitude: -74.1, latitude: 40.7 },
-                    { longitude: -74.2, latitude: 40.8 }
+                    [-74.1, 40.7],
+                    [-74.2, 40.8]
                 ],
                 routing_profile: 'driving',
                 arrive_by: '2025-06-05T10:30:00+02:00'
@@ -809,8 +716,8 @@ describe('DirectionsTool', () => {
             // Test with simple time format (no seconds, no timezone)
             await new DirectionsTool().run({
                 coordinates: [
-                    { longitude: -74.1, latitude: 40.7 },
-                    { longitude: -74.2, latitude: 40.8 }
+                    [-74.1, 40.7],
+                    [-74.2, 40.8]
                 ],
                 routing_profile: 'driving',
                 arrive_by: '2025-06-05T10:30'
@@ -836,8 +743,8 @@ describe('DirectionsTool', () => {
             for (const format of invalidFormats) {
                 const result = await new DirectionsTool().run({
                     coordinates: [
-                        { longitude: -74.1, latitude: 40.7 },
-                        { longitude: -74.2, latitude: 40.8 }
+                        [-74.1, 40.7],
+                        [-74.2, 40.8]
                     ],
                     routing_profile: 'driving',
                     arrive_by: format
@@ -857,8 +764,8 @@ describe('DirectionsTool', () => {
             for (const date of invalidDates) {
                 const result = await new DirectionsTool().run({
                     coordinates: [
-                        { longitude: -74.1, latitude: 40.7 },
-                        { longitude: -74.2, latitude: 40.8 }
+                        [-74.1, 40.7],
+                        [-74.2, 40.8]
                     ],
                     routing_profile: 'driving',
                     arrive_by: date
@@ -867,5 +774,49 @@ 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