@mapbox/mcp-server 0.9.2-dev → 0.12.3-dev

package/dist/commonjs/tools/map-matching-tool/MapMatchingTool.output.schema.d.ts

@@ -5,166 +5,28 @@ export declare const MapMatchingOutputSchema: z.ZodObject<{
         confidence: z.ZodNumber;
         distance: z.ZodNumber;
         duration: z.ZodNumber;
-        geometry: z.ZodUnion<[z.ZodObject<{
+        geometry: z.ZodUnion<readonly [z.ZodObject<{
             type: z.ZodLiteral<"LineString">;
-            coordinates: z.ZodArray<z.ZodUnion<[z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>]>, "many">;
-        }, "strip", z.ZodTypeAny, {
-            type: "LineString";
-            coordinates: ([number, number] | [number, number, number])[];
-        }, {
-            type: "LineString";
-            coordinates: ([number, number] | [number, number, number])[];
-        }>, z.ZodString]>;
+            coordinates: z.ZodArray<z.ZodUnion<[z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>]>>;
+        }, z.core.$strip>, z.ZodString]>;
         legs: z.ZodOptional<z.ZodArray<z.ZodObject<{
             distance: z.ZodNumber;
             duration: z.ZodNumber;
             annotation: z.ZodOptional<z.ZodObject<{
-                speed: z.ZodOptional<z.ZodArray<z.ZodNumber, "many">>;
-                distance: z.ZodOptional<z.ZodArray<z.ZodNumber, "many">>;
-                duration: z.ZodOptional<z.ZodArray<z.ZodNumber, "many">>;
-                congestion: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-            }, "strip", z.ZodTypeAny, {
-                distance?: number[] | undefined;
-                speed?: number[] | undefined;
-                congestion?: string[] | undefined;
-                duration?: number[] | undefined;
-            }, {
-                distance?: number[] | undefined;
-                speed?: number[] | undefined;
-                congestion?: string[] | undefined;
-                duration?: number[] | undefined;
-            }>>;
-        }, "strip", z.ZodTypeAny, {
-            distance: number;
-            duration: number;
-            annotation?: {
-                distance?: number[] | undefined;
-                speed?: number[] | undefined;
-                congestion?: string[] | undefined;
-                duration?: number[] | undefined;
-            } | undefined;
-        }, {
-            distance: number;
-            duration: number;
-            annotation?: {
-                distance?: number[] | undefined;
-                speed?: number[] | undefined;
-                congestion?: string[] | undefined;
-                duration?: number[] | undefined;
-            } | undefined;
-        }>, "many">>;
-    }, "strip", z.ZodTypeAny, {
-        geometry: string | {
-            type: "LineString";
-            coordinates: ([number, number] | [number, number, number])[];
-        };
-        distance: number;
-        duration: number;
-        confidence: number;
-        legs?: {
-            distance: number;
-            duration: number;
-            annotation?: {
-                distance?: number[] | undefined;
-                speed?: number[] | undefined;
-                congestion?: string[] | undefined;
-                duration?: number[] | undefined;
-            } | undefined;
-        }[] | undefined;
-    }, {
-        geometry: string | {
-            type: "LineString";
-            coordinates: ([number, number] | [number, number, number])[];
-        };
-        distance: number;
-        duration: number;
-        confidence: number;
-        legs?: {
-            distance: number;
-            duration: number;
-            annotation?: {
-                distance?: number[] | undefined;
-                speed?: number[] | undefined;
-                congestion?: string[] | undefined;
-                duration?: number[] | undefined;
-            } | undefined;
-        }[] | undefined;
-    }>, "many">;
+                speed: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+                distance: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+                duration: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+                congestion: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
     tracepoints: z.ZodArray<z.ZodNullable<z.ZodObject<{
         name: z.ZodOptional<z.ZodString>;
         location: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
         waypoint_index: z.ZodOptional<z.ZodNumber>;
         matchings_index: z.ZodNumber;
         alternatives_count: z.ZodNumber;
-    }, "strip", z.ZodTypeAny, {
-        location: [number, number];
-        matchings_index: number;
-        alternatives_count: number;
-        name?: string | undefined;
-        waypoint_index?: number | undefined;
-    }, {
-        location: [number, number];
-        matchings_index: number;
-        alternatives_count: number;
-        name?: string | undefined;
-        waypoint_index?: number | undefined;
-    }>>, "many">;
-}, "strip", z.ZodTypeAny, {
-    code: string;
-    matchings: {
-        geometry: string | {
-            type: "LineString";
-            coordinates: ([number, number] | [number, number, number])[];
-        };
-        distance: number;
-        duration: number;
-        confidence: number;
-        legs?: {
-            distance: number;
-            duration: number;
-            annotation?: {
-                distance?: number[] | undefined;
-                speed?: number[] | undefined;
-                congestion?: string[] | undefined;
-                duration?: number[] | undefined;
-            } | undefined;
-        }[] | undefined;
-    }[];
-    tracepoints: ({
-        location: [number, number];
-        matchings_index: number;
-        alternatives_count: number;
-        name?: string | undefined;
-        waypoint_index?: number | undefined;
-    } | null)[];
-}, {
-    code: string;
-    matchings: {
-        geometry: string | {
-            type: "LineString";
-            coordinates: ([number, number] | [number, number, number])[];
-        };
-        distance: number;
-        duration: number;
-        confidence: number;
-        legs?: {
-            distance: number;
-            duration: number;
-            annotation?: {
-                distance?: number[] | undefined;
-                speed?: number[] | undefined;
-                congestion?: string[] | undefined;
-                duration?: number[] | undefined;
-            } | undefined;
-        }[] | undefined;
-    }[];
-    tracepoints: ({
-        location: [number, number];
-        matchings_index: number;
-        alternatives_count: number;
-        name?: string | undefined;
-        waypoint_index?: number | undefined;
-    } | null)[];
-}>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
 export type MapMatchingOutput = z.infer<typeof MapMatchingOutputSchema>;
 //# sourceMappingURL=MapMatchingTool.output.schema.d.ts.map

package/dist/commonjs/tools/map-matching-tool/MapMatchingTool.output.schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"MapMatchingTool.output.schema.d.ts","sourceRoot":"","sources":["../../../../src/tools/map-matching-tool/MapMatchingTool.output.schema.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AA8CxB,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAIlC,CAAC;AAEH,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC"}
+{"version":3,"file":"MapMatchingTool.output.schema.d.ts","sourceRoot":"","sources":["../../../../src/tools/map-matching-tool/MapMatchingTool.output.schema.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AA8CxB,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAIlC,CAAC;AAEH,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC"}

package/dist/commonjs/tools/matrix-tool/MatrixTool.input.schema.d.ts

@@ -3,40 +3,22 @@ export declare const MatrixInputSchema: z.ZodObject<{
     coordinates: z.ZodArray<z.ZodObject<{
         longitude: z.ZodNumber;
         latitude: z.ZodNumber;
-    }, "strip", z.ZodTypeAny, {
-        longitude: number;
-        latitude: number;
-    }, {
-        longitude: number;
-        latitude: number;
-    }>, "many">;
-    profile: z.ZodEnum<["mapbox/driving-traffic", "mapbox/driving", "mapbox/walking", "mapbox/cycling"]>;
-    annotations: z.ZodOptional<z.ZodEnum<["duration", "distance", "duration,distance", "distance,duration"]>>;
+    }, z.core.$strip>>;
+    profile: z.ZodEnum<{
+        "mapbox/driving-traffic": "mapbox/driving-traffic";
+        "mapbox/driving": "mapbox/driving";
+        "mapbox/walking": "mapbox/walking";
+        "mapbox/cycling": "mapbox/cycling";
+    }>;
+    annotations: z.ZodOptional<z.ZodEnum<{
+        distance: "distance";
+        duration: "duration";
+        "duration,distance": "duration,distance";
+        "distance,duration": "distance,duration";
+    }>>;
     approaches: z.ZodOptional<z.ZodString>;
     bearings: z.ZodOptional<z.ZodString>;
     destinations: z.ZodOptional<z.ZodString>;
     sources: z.ZodOptional<z.ZodString>;
-}, "strip", z.ZodTypeAny, {
-    coordinates: {
-        longitude: number;
-        latitude: number;
-    }[];
-    profile: "mapbox/driving-traffic" | "mapbox/driving" | "mapbox/walking" | "mapbox/cycling";
-    annotations?: "distance" | "duration" | "duration,distance" | "distance,duration" | undefined;
-    bearings?: string | undefined;
-    destinations?: string | undefined;
-    approaches?: string | undefined;
-    sources?: string | undefined;
-}, {
-    coordinates: {
-        longitude: number;
-        latitude: number;
-    }[];
-    profile: "mapbox/driving-traffic" | "mapbox/driving" | "mapbox/walking" | "mapbox/cycling";
-    annotations?: "distance" | "duration" | "duration,distance" | "distance,duration" | undefined;
-    bearings?: string | undefined;
-    destinations?: string | undefined;
-    approaches?: string | undefined;
-    sources?: string | undefined;
-}>;
+}, z.core.$strip>;
 //# sourceMappingURL=MatrixTool.input.schema.d.ts.map

package/dist/commonjs/tools/matrix-tool/MatrixTool.input.schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"MatrixTool.input.schema.d.ts","sourceRoot":"","sources":["../../../../src/tools/matrix-tool/MatrixTool.input.schema.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA8D5B,CAAC"}
+{"version":3,"file":"MatrixTool.input.schema.d.ts","sourceRoot":"","sources":["../../../../src/tools/matrix-tool/MatrixTool.input.schema.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;iBA8D5B,CAAC"}

package/dist/commonjs/tools/matrix-tool/MatrixTool.output.schema.d.ts

@@ -3,77 +3,23 @@ declare const MatrixWaypointSchema: z.ZodObject<{
     name: z.ZodString;
     location: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
     distance: z.ZodNumber;
-}, "strip", z.ZodTypeAny, {
-    name: string;
-    distance: number;
-    location: [number, number];
-}, {
-    name: string;
-    distance: number;
-    location: [number, number];
-}>;
+}, z.core.$strip>;
 export declare const MatrixResponseSchema: z.ZodObject<{
     code: z.ZodString;
-    durations: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodNullable<z.ZodNumber>, "many">, "many">>;
-    distances: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodNullable<z.ZodNumber>, "many">, "many">>;
+    durations: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodNullable<z.ZodNumber>>>>;
+    distances: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodNullable<z.ZodNumber>>>>;
     sources: z.ZodArray<z.ZodObject<{
         name: z.ZodString;
         location: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
         distance: z.ZodNumber;
-    }, "strip", z.ZodTypeAny, {
-        name: string;
-        distance: number;
-        location: [number, number];
-    }, {
-        name: string;
-        distance: number;
-        location: [number, number];
-    }>, "many">;
+    }, z.core.$strip>>;
     destinations: z.ZodArray<z.ZodObject<{
         name: z.ZodString;
         location: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
         distance: z.ZodNumber;
-    }, "strip", z.ZodTypeAny, {
-        name: string;
-        distance: number;
-        location: [number, number];
-    }, {
-        name: string;
-        distance: number;
-        location: [number, number];
-    }>, "many">;
+    }, z.core.$strip>>;
     message: z.ZodOptional<z.ZodString>;
-}, "strip", z.ZodTypeAny, {
-    code: string;
-    destinations: {
-        name: string;
-        distance: number;
-        location: [number, number];
-    }[];
-    sources: {
-        name: string;
-        distance: number;
-        location: [number, number];
-    }[];
-    message?: string | undefined;
-    durations?: (number | null)[][] | undefined;
-    distances?: (number | null)[][] | undefined;
-}, {
-    code: string;
-    destinations: {
-        name: string;
-        distance: number;
-        location: [number, number];
-    }[];
-    sources: {
-        name: string;
-        distance: number;
-        location: [number, number];
-    }[];
-    message?: string | undefined;
-    durations?: (number | null)[][] | undefined;
-    distances?: (number | null)[][] | undefined;
-}>;
+}, z.core.$strip>;
 export type MatrixResponse = z.infer<typeof MatrixResponseSchema>;
 export type MatrixWaypoint = z.infer<typeof MatrixWaypointSchema>;
 export {};

package/dist/commonjs/tools/matrix-tool/MatrixTool.output.schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"MatrixTool.output.schema.d.ts","sourceRoot":"","sources":["../../../../src/tools/matrix-tool/MatrixTool.output.schema.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,QAAA,MAAM,oBAAoB;;;;;;;;;;;;EAIxB,CAAC;AAGH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAO/B,CAAC;AAEH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAClE,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC"}
+{"version":3,"file":"MatrixTool.output.schema.d.ts","sourceRoot":"","sources":["../../../../src/tools/matrix-tool/MatrixTool.output.schema.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,QAAA,MAAM,oBAAoB;;;;iBAIxB,CAAC;AAGH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;iBAO/B,CAAC;AAEH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAClE,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC"}

package/dist/commonjs/tools/midpoint-tool/MidpointTool.input.schema.d.ts

@@ -6,42 +6,12 @@ export declare const MidpointInputSchema: z.ZodObject<{
     from: z.ZodObject<{
         longitude: z.ZodNumber;
         latitude: z.ZodNumber;
-    }, "strip", z.ZodTypeAny, {
-        longitude: number;
-        latitude: number;
-    }, {
-        longitude: number;
-        latitude: number;
-    }>;
+    }, z.core.$strip>;
     to: z.ZodObject<{
         longitude: z.ZodNumber;
         latitude: z.ZodNumber;
-    }, "strip", z.ZodTypeAny, {
-        longitude: number;
-        latitude: number;
-    }, {
-        longitude: number;
-        latitude: number;
-    }>;
-}, "strip", z.ZodTypeAny, {
-    from: {
-        longitude: number;
-        latitude: number;
-    };
-    to: {
-        longitude: number;
-        latitude: number;
-    };
-}, {
-    from: {
-        longitude: number;
-        latitude: number;
-    };
-    to: {
-        longitude: number;
-        latitude: number;
-    };
-}>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
 /**
  * Type inference for MidpointInput
  */

package/dist/commonjs/tools/midpoint-tool/MidpointTool.input.schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"MidpointTool.input.schema.d.ts","sourceRoot":"","sources":["../../../../src/tools/midpoint-tool/MidpointTool.input.schema.ts"],"names":[],"mappings":"AAGA,OAAO,CAAC,MAAM,KAAK,CAAC;AAEpB;;GAEG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAa9B,CAAC;AAEH;;GAEG;AACH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC"}
+{"version":3,"file":"MidpointTool.input.schema.d.ts","sourceRoot":"","sources":["../../../../src/tools/midpoint-tool/MidpointTool.input.schema.ts"],"names":[],"mappings":"AAGA,OAAO,CAAC,MAAM,KAAK,CAAC;AAEpB;;GAEG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;iBAa9B,CAAC;AAEH;;GAEG;AACH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC"}

package/dist/commonjs/tools/midpoint-tool/MidpointTool.output.schema.d.ts

@@ -6,60 +6,16 @@ export declare const MidpointOutputSchema: z.ZodObject<{
     midpoint: z.ZodObject<{
         longitude: z.ZodNumber;
         latitude: z.ZodNumber;
-    }, "strip", z.ZodTypeAny, {
-        longitude: number;
-        latitude: number;
-    }, {
-        longitude: number;
-        latitude: number;
-    }>;
+    }, z.core.$strip>;
     from: z.ZodObject<{
         longitude: z.ZodNumber;
         latitude: z.ZodNumber;
-    }, "strip", z.ZodTypeAny, {
-        longitude: number;
-        latitude: number;
-    }, {
-        longitude: number;
-        latitude: number;
-    }>;
+    }, z.core.$strip>;
     to: z.ZodObject<{
         longitude: z.ZodNumber;
         latitude: z.ZodNumber;
-    }, "strip", z.ZodTypeAny, {
-        longitude: number;
-        latitude: number;
-    }, {
-        longitude: number;
-        latitude: number;
-    }>;
-}, "strip", z.ZodTypeAny, {
-    from: {
-        longitude: number;
-        latitude: number;
-    };
-    to: {
-        longitude: number;
-        latitude: number;
-    };
-    midpoint: {
-        longitude: number;
-        latitude: number;
-    };
-}, {
-    from: {
-        longitude: number;
-        latitude: number;
-    };
-    to: {
-        longitude: number;
-        latitude: number;
-    };
-    midpoint: {
-        longitude: number;
-        latitude: number;
-    };
-}>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
 /**
  * Type inference for MidpointOutput
  */

package/dist/commonjs/tools/midpoint-tool/MidpointTool.output.schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"MidpointTool.output.schema.d.ts","sourceRoot":"","sources":["../../../../src/tools/midpoint-tool/MidpointTool.output.schema.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;GAEG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAa/B,CAAC;AAEH;;GAEG;AACH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC"}
+{"version":3,"file":"MidpointTool.output.schema.d.ts","sourceRoot":"","sources":["../../../../src/tools/midpoint-tool/MidpointTool.output.schema.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;GAEG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;iBAa/B,CAAC;AAEH;;GAEG;AACH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC"}

package/dist/commonjs/tools/nearest-point-on-line-tool/NearestPointOnLineTool.d.ts

@@ -0,0 +1,18 @@
+import { BaseTool } from '../BaseTool.js';
+import { NearestPointOnLineInputSchema } from './NearestPointOnLineTool.input.schema.js';
+import { NearestPointOnLineOutputSchema } from './NearestPointOnLineTool.output.schema.js';
+import type { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
+export declare class NearestPointOnLineTool extends BaseTool<typeof NearestPointOnLineInputSchema, typeof NearestPointOnLineOutputSchema> {
+    readonly name = "nearest_point_on_line_tool";
+    readonly description: string;
+    readonly annotations: {
+        title: string;
+        readOnlyHint: boolean;
+        destructiveHint: boolean;
+        idempotentHint: boolean;
+        openWorldHint: boolean;
+    };
+    constructor();
+    run(rawInput: unknown): Promise<CallToolResult>;
+}
+//# sourceMappingURL=NearestPointOnLineTool.d.ts.map

package/dist/commonjs/tools/nearest-point-on-line-tool/NearestPointOnLineTool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NearestPointOnLineTool.d.ts","sourceRoot":"","sources":["../../../../src/tools/nearest-point-on-line-tool/NearestPointOnLineTool.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAC1C,OAAO,EAAE,6BAA6B,EAAE,MAAM,0CAA0C,CAAC;AACzF,OAAO,EACL,8BAA8B,EAE/B,MAAM,2CAA2C,CAAC;AACnD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oCAAoC,CAAC;AAEzE,qBAAa,sBAAuB,SAAQ,QAAQ,CAClD,OAAO,6BAA6B,EACpC,OAAO,8BAA8B,CACtC;IACC,QAAQ,CAAC,IAAI,gCAAgC;IAC7C,QAAQ,CAAC,WAAW,SAIiB;IAErC,QAAQ,CAAC,WAAW;;;;;;MAMlB;;IASI,GAAG,CAAC,QAAQ,EAAE,OAAO,GAAG,OAAO,CAAC,cAAc,CAAC;CA4DtD"}

package/dist/commonjs/tools/nearest-point-on-line-tool/NearestPointOnLineTool.input.schema.d.ts

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+export declare const NearestPointOnLineInputSchema: z.ZodObject<{
+    point: z.ZodObject<{
+        longitude: z.ZodNumber;
+        latitude: z.ZodNumber;
+    }, z.core.$strip>;
+    line: z.ZodArray<z.ZodArray<z.ZodNumber>>;
+    units: z.ZodDefault<z.ZodEnum<{
+        kilometers: "kilometers";
+        miles: "miles";
+        meters: "meters";
+        feet: "feet";
+    }>>;
+}, z.core.$strip>;
+export type NearestPointOnLineInput = z.infer<typeof NearestPointOnLineInputSchema>;
+//# sourceMappingURL=NearestPointOnLineTool.input.schema.d.ts.map

package/dist/commonjs/tools/nearest-point-on-line-tool/NearestPointOnLineTool.input.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NearestPointOnLineTool.input.schema.d.ts","sourceRoot":"","sources":["../../../../src/tools/nearest-point-on-line-tool/NearestPointOnLineTool.input.schema.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAOxB,eAAO,MAAM,6BAA6B;;;;;;;;;;;;iBAiBxC,CAAC;AAEH,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAC3C,OAAO,6BAA6B,CACrC,CAAC"}

package/dist/commonjs/tools/nearest-point-on-line-tool/NearestPointOnLineTool.input.schema.js

@@ -0,0 +1,27 @@
+"use strict";
+// Copyright (c) Mapbox, Inc.
+// Licensed under the MIT License.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NearestPointOnLineInputSchema = void 0;
+const zod_1 = require("zod");
+const CoordinateSchema = zod_1.z
+    .array(zod_1.z.number())
+    .length(2)
+    .describe('Coordinate as [longitude, latitude]');
+exports.NearestPointOnLineInputSchema = zod_1.z.object({
+    point: zod_1.z
+        .object({
+        longitude: zod_1.z.number().min(-180).max(180),
+        latitude: zod_1.z.number().min(-90).max(90)
+    })
+        .describe('The point to snap to the line'),
+    line: zod_1.z
+        .array(CoordinateSchema)
+        .min(2)
+        .describe('LineString coordinates as [longitude, latitude] pairs'),
+    units: zod_1.z
+        .enum(['kilometers', 'miles', 'meters', 'feet'])
+        .default('kilometers')
+        .describe('Units for the distance result')
+});
+//# sourceMappingURL=NearestPointOnLineTool.input.schema.js.map

package/dist/commonjs/tools/nearest-point-on-line-tool/NearestPointOnLineTool.input.schema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"NearestPointOnLineTool.input.schema.js","sourceRoot":"","sources":["../../../../src/tools/nearest-point-on-line-tool/NearestPointOnLineTool.input.schema.ts"],"names":[],"mappings":";AAAA,6BAA6B;AAC7B,kCAAkC;;;AAElC,6BAAwB;AAExB,MAAM,gBAAgB,GAAG,OAAC;KACvB,KAAK,CAAC,OAAC,CAAC,MAAM,EAAE,CAAC;KACjB,MAAM,CAAC,CAAC,CAAC;KACT,QAAQ,CAAC,qCAAqC,CAAC,CAAC;AAEtC,QAAA,6BAA6B,GAAG,OAAC,CAAC,MAAM,CAAC;IACpD,KAAK,EAAE,OAAC;SACL,MAAM,CAAC;QACN,SAAS,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC;QACxC,QAAQ,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,CAAC,EAAE,CAAC;KACtC,CAAC;SACD,QAAQ,CAAC,+BAA+B,CAAC;IAE5C,IAAI,EAAE,OAAC;SACJ,KAAK,CAAC,gBAAgB,CAAC;SACvB,GAAG,CAAC,CAAC,CAAC;SACN,QAAQ,CAAC,uDAAuD,CAAC;IAEpE,KAAK,EAAE,OAAC;SACL,IAAI,CAAC,CAAC,YAAY,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,CAAC,CAAC;SAC/C,OAAO,CAAC,YAAY,CAAC;SACrB,QAAQ,CAAC,+BAA+B,CAAC;CAC7C,CAAC,CAAC"}

package/dist/commonjs/tools/nearest-point-on-line-tool/NearestPointOnLineTool.js

@@ -0,0 +1,81 @@
+"use strict";
+// Copyright (c) Mapbox, Inc.
+// Licensed under the MIT License.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NearestPointOnLineTool = void 0;
+const turf_1 = require("@turf/turf");
+const api_1 = require("@opentelemetry/api");
+const tracing_js_1 = require("../../utils/tracing.js");
+const BaseTool_js_1 = require("../BaseTool.js");
+const NearestPointOnLineTool_input_schema_js_1 = require("./NearestPointOnLineTool.input.schema.js");
+const NearestPointOnLineTool_output_schema_js_1 = require("./NearestPointOnLineTool.output.schema.js");
+class NearestPointOnLineTool extends BaseTool_js_1.BaseTool {
+    name = 'nearest_point_on_line_tool';
+    description = 'Snap a point to the nearest position on a line or route. ' +
+        'Returns the closest point on the line and the distance to it. ' +
+        'Useful for "which point on this route is closest to my location?" or map-matching without the API. ' +
+        'Works offline without API calls.';
+    annotations = {
+        title: 'Nearest Point on Line',
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false
+    };
+    constructor() {
+        super({
+            inputSchema: NearestPointOnLineTool_input_schema_js_1.NearestPointOnLineInputSchema,
+            outputSchema: NearestPointOnLineTool_output_schema_js_1.NearestPointOnLineOutputSchema
+        });
+    }
+    async run(rawInput) {
+        const toolContext = (0, tracing_js_1.createLocalToolExecutionContext)(this.name, 0);
+        return await api_1.context.with(api_1.trace.setSpan(api_1.context.active(), toolContext.span), async () => {
+            try {
+                const input = NearestPointOnLineTool_input_schema_js_1.NearestPointOnLineInputSchema.parse(rawInput);
+                const pt = (0, turf_1.point)([input.point.longitude, input.point.latitude]);
+                const line = (0, turf_1.lineString)(input.line);
+                const result = (0, turf_1.nearestPointOnLine)(line, pt, { units: input.units });
+                const output = {
+                    nearest: {
+                        longitude: result.geometry.coordinates[0],
+                        latitude: result.geometry.coordinates[1]
+                    },
+                    distance: result.properties?.dist ?? 0,
+                    units: input.units,
+                    location: result.properties?.location ?? 0
+                };
+                const validated = this.validateOutput(output);
+                const text = `Nearest point on line: [${validated.nearest.longitude}, ${validated.nearest.latitude}]\n` +
+                    `Distance from input point: ${validated.distance} ${validated.units}\n` +
+                    `Distance along line: ${validated.location} ${validated.units}`;
+                toolContext.span.setStatus({ code: api_1.SpanStatusCode.OK });
+                toolContext.span.end();
+                return {
+                    content: [{ type: 'text', text }],
+                    structuredContent: validated,
+                    isError: false
+                };
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                toolContext.span.setStatus({
+                    code: api_1.SpanStatusCode.ERROR,
+                    message: errorMessage
+                });
+                toolContext.span.end();
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `NearestPointOnLineTool: ${errorMessage}`
+                        }
+                    ],
+                    isError: true
+                };
+            }
+        });
+    }
+}
+exports.NearestPointOnLineTool = NearestPointOnLineTool;
+//# sourceMappingURL=NearestPointOnLineTool.js.map

package/dist/commonjs/tools/nearest-point-on-line-tool/NearestPointOnLineTool.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"NearestPointOnLineTool.js","sourceRoot":"","sources":["../../../../src/tools/nearest-point-on-line-tool/NearestPointOnLineTool.ts"],"names":[],"mappings":"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"}

package/dist/commonjs/tools/nearest-point-on-line-tool/NearestPointOnLineTool.output.schema.d.ts

@@ -0,0 +1,12 @@
+import { z } from 'zod';
+export declare const NearestPointOnLineOutputSchema: z.ZodObject<{
+    nearest: z.ZodObject<{
+        longitude: z.ZodNumber;
+        latitude: z.ZodNumber;
+    }, z.core.$strip>;
+    distance: z.ZodNumber;
+    units: z.ZodString;
+    location: z.ZodNumber;
+}, z.core.$strip>;
+export type NearestPointOnLineOutput = z.infer<typeof NearestPointOnLineOutputSchema>;
+//# sourceMappingURL=NearestPointOnLineTool.output.schema.d.ts.map

package/dist/commonjs/tools/nearest-point-on-line-tool/NearestPointOnLineTool.output.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NearestPointOnLineTool.output.schema.d.ts","sourceRoot":"","sources":["../../../../src/tools/nearest-point-on-line-tool/NearestPointOnLineTool.output.schema.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,8BAA8B;;;;;;;;iBAYzC,CAAC;AAEH,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAC5C,OAAO,8BAA8B,CACtC,CAAC"}