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

package/dist/esm/tools/isochrone-tool/IsochroneTool.output.schema.d.ts

@@ -4,162 +4,54 @@ import { z } from 'zod';
  * https://docs.mapbox.com/api/navigation/isochrone/
  */
 export declare const IsochroneFeaturePropertiesSchema: z.ZodObject<{
-    /** The value of the metric used in this contour (time in minutes or distance in meters) */
     contour: z.ZodNumber;
-    /** The color of the isochrone line if the geometry is LineString */
     color: z.ZodOptional<z.ZodString>;
-    /** The opacity of the isochrone line if the geometry is LineString */
     opacity: z.ZodOptional<z.ZodNumber>;
-    /** The fill color of the isochrone polygon if the geometry is Polygon (geojson.io format) */
     fill: z.ZodOptional<z.ZodString>;
-    /** The fill opacity of the isochrone polygon if the geometry is Polygon (geojson.io format) */
     'fill-opacity': z.ZodOptional<z.ZodNumber>;
-    /** The fill color of the isochrone polygon if the geometry is Polygon (Leaflet format) */
     fillColor: z.ZodOptional<z.ZodString>;
-    /** The fill opacity of the isochrone polygon if the geometry is Polygon (Leaflet format) */
     fillOpacity: z.ZodOptional<z.ZodNumber>;
-    /** The metric that the contour represents - either "distance" or "time" */
-    metric: z.ZodOptional<z.ZodEnum<["distance", "time"]>>;
-}, "strip", z.ZodTypeAny, {
-    contour: number;
-    fill?: string | undefined;
-    color?: string | undefined;
-    opacity?: number | undefined;
-    'fill-opacity'?: number | undefined;
-    fillColor?: string | undefined;
-    fillOpacity?: number | undefined;
-    metric?: "time" | "distance" | undefined;
-}, {
-    contour: number;
-    fill?: string | undefined;
-    color?: string | undefined;
-    opacity?: number | undefined;
-    'fill-opacity'?: number | undefined;
-    fillColor?: string | undefined;
-    fillOpacity?: number | undefined;
-    metric?: "time" | "distance" | undefined;
-}>;
+    metric: z.ZodOptional<z.ZodEnum<{
+        time: "time";
+        distance: "distance";
+    }>>;
+}, z.core.$strip>;
 /**
  * Isochrone geometry - can be either LineString or Polygon
  */
-export declare const IsochroneGeometrySchema: z.ZodUnion<[z.ZodObject<{
+export declare const IsochroneGeometrySchema: z.ZodUnion<readonly [z.ZodObject<{
     type: z.ZodLiteral<"LineString">;
-    coordinates: z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, "many">;
-}, "strip", z.ZodTypeAny, {
-    type: "LineString";
-    coordinates: [number, number][];
-}, {
-    type: "LineString";
-    coordinates: [number, number][];
-}>, z.ZodObject<{
+    coordinates: z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+}, z.core.$strip>, z.ZodObject<{
     type: z.ZodLiteral<"Polygon">;
-    coordinates: z.ZodArray<z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, "many">, "many">;
-}, "strip", z.ZodTypeAny, {
-    type: "Polygon";
-    coordinates: [number, number][][];
-}, {
-    type: "Polygon";
-    coordinates: [number, number][][];
-}>]>;
+    coordinates: z.ZodArray<z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>>;
+}, z.core.$strip>]>;
 /**
  * Individual isochrone feature
  */
 export declare const IsochroneFeatureSchema: z.ZodObject<{
     type: z.ZodLiteral<"Feature">;
     properties: z.ZodObject<{
-        /** The value of the metric used in this contour (time in minutes or distance in meters) */
         contour: z.ZodNumber;
-        /** The color of the isochrone line if the geometry is LineString */
         color: z.ZodOptional<z.ZodString>;
-        /** The opacity of the isochrone line if the geometry is LineString */
         opacity: z.ZodOptional<z.ZodNumber>;
-        /** The fill color of the isochrone polygon if the geometry is Polygon (geojson.io format) */
         fill: z.ZodOptional<z.ZodString>;
-        /** The fill opacity of the isochrone polygon if the geometry is Polygon (geojson.io format) */
         'fill-opacity': z.ZodOptional<z.ZodNumber>;
-        /** The fill color of the isochrone polygon if the geometry is Polygon (Leaflet format) */
         fillColor: z.ZodOptional<z.ZodString>;
-        /** The fill opacity of the isochrone polygon if the geometry is Polygon (Leaflet format) */
         fillOpacity: z.ZodOptional<z.ZodNumber>;
-        /** The metric that the contour represents - either "distance" or "time" */
-        metric: z.ZodOptional<z.ZodEnum<["distance", "time"]>>;
-    }, "strip", z.ZodTypeAny, {
-        contour: number;
-        fill?: string | undefined;
-        color?: string | undefined;
-        opacity?: number | undefined;
-        'fill-opacity'?: number | undefined;
-        fillColor?: string | undefined;
-        fillOpacity?: number | undefined;
-        metric?: "time" | "distance" | undefined;
-    }, {
-        contour: number;
-        fill?: string | undefined;
-        color?: string | undefined;
-        opacity?: number | undefined;
-        'fill-opacity'?: number | undefined;
-        fillColor?: string | undefined;
-        fillOpacity?: number | undefined;
-        metric?: "time" | "distance" | undefined;
-    }>;
-    geometry: z.ZodUnion<[z.ZodObject<{
+        metric: z.ZodOptional<z.ZodEnum<{
+            time: "time";
+            distance: "distance";
+        }>>;
+    }, z.core.$strip>;
+    geometry: z.ZodUnion<readonly [z.ZodObject<{
         type: z.ZodLiteral<"LineString">;
-        coordinates: z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, "many">;
-    }, "strip", z.ZodTypeAny, {
-        type: "LineString";
-        coordinates: [number, number][];
-    }, {
-        type: "LineString";
-        coordinates: [number, number][];
-    }>, z.ZodObject<{
+        coordinates: z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+    }, z.core.$strip>, z.ZodObject<{
         type: z.ZodLiteral<"Polygon">;
-        coordinates: z.ZodArray<z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, "many">, "many">;
-    }, "strip", z.ZodTypeAny, {
-        type: "Polygon";
-        coordinates: [number, number][][];
-    }, {
-        type: "Polygon";
-        coordinates: [number, number][][];
-    }>]>;
-}, "strip", z.ZodTypeAny, {
-    type: "Feature";
-    geometry: {
-        type: "LineString";
-        coordinates: [number, number][];
-    } | {
-        type: "Polygon";
-        coordinates: [number, number][][];
-    };
-    properties: {
-        contour: number;
-        fill?: string | undefined;
-        color?: string | undefined;
-        opacity?: number | undefined;
-        'fill-opacity'?: number | undefined;
-        fillColor?: string | undefined;
-        fillOpacity?: number | undefined;
-        metric?: "time" | "distance" | undefined;
-    };
-}, {
-    type: "Feature";
-    geometry: {
-        type: "LineString";
-        coordinates: [number, number][];
-    } | {
-        type: "Polygon";
-        coordinates: [number, number][][];
-    };
-    properties: {
-        contour: number;
-        fill?: string | undefined;
-        color?: string | undefined;
-        opacity?: number | undefined;
-        'fill-opacity'?: number | undefined;
-        fillColor?: string | undefined;
-        fillOpacity?: number | undefined;
-        metric?: "time" | "distance" | undefined;
-    };
-}>;
+        coordinates: z.ZodArray<z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>>;
+    }, z.core.$strip>]>;
+}, z.core.$strip>;
 /**
  * Complete Isochrone API response
  * Returns a GeoJSON FeatureCollection containing isochrone contours
@@ -169,144 +61,27 @@ export declare const IsochroneResponseSchema: z.ZodObject<{
     features: z.ZodArray<z.ZodObject<{
         type: z.ZodLiteral<"Feature">;
         properties: z.ZodObject<{
-            /** The value of the metric used in this contour (time in minutes or distance in meters) */
             contour: z.ZodNumber;
-            /** The color of the isochrone line if the geometry is LineString */
             color: z.ZodOptional<z.ZodString>;
-            /** The opacity of the isochrone line if the geometry is LineString */
             opacity: z.ZodOptional<z.ZodNumber>;
-            /** The fill color of the isochrone polygon if the geometry is Polygon (geojson.io format) */
             fill: z.ZodOptional<z.ZodString>;
-            /** The fill opacity of the isochrone polygon if the geometry is Polygon (geojson.io format) */
             'fill-opacity': z.ZodOptional<z.ZodNumber>;
-            /** The fill color of the isochrone polygon if the geometry is Polygon (Leaflet format) */
             fillColor: z.ZodOptional<z.ZodString>;
-            /** The fill opacity of the isochrone polygon if the geometry is Polygon (Leaflet format) */
             fillOpacity: z.ZodOptional<z.ZodNumber>;
-            /** The metric that the contour represents - either "distance" or "time" */
-            metric: z.ZodOptional<z.ZodEnum<["distance", "time"]>>;
-        }, "strip", z.ZodTypeAny, {
-            contour: number;
-            fill?: string | undefined;
-            color?: string | undefined;
-            opacity?: number | undefined;
-            'fill-opacity'?: number | undefined;
-            fillColor?: string | undefined;
-            fillOpacity?: number | undefined;
-            metric?: "time" | "distance" | undefined;
-        }, {
-            contour: number;
-            fill?: string | undefined;
-            color?: string | undefined;
-            opacity?: number | undefined;
-            'fill-opacity'?: number | undefined;
-            fillColor?: string | undefined;
-            fillOpacity?: number | undefined;
-            metric?: "time" | "distance" | undefined;
-        }>;
-        geometry: z.ZodUnion<[z.ZodObject<{
+            metric: z.ZodOptional<z.ZodEnum<{
+                time: "time";
+                distance: "distance";
+            }>>;
+        }, z.core.$strip>;
+        geometry: z.ZodUnion<readonly [z.ZodObject<{
             type: z.ZodLiteral<"LineString">;
-            coordinates: z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, "many">;
-        }, "strip", z.ZodTypeAny, {
-            type: "LineString";
-            coordinates: [number, number][];
-        }, {
-            type: "LineString";
-            coordinates: [number, number][];
-        }>, z.ZodObject<{
+            coordinates: z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+        }, z.core.$strip>, z.ZodObject<{
             type: z.ZodLiteral<"Polygon">;
-            coordinates: z.ZodArray<z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, "many">, "many">;
-        }, "strip", z.ZodTypeAny, {
-            type: "Polygon";
-            coordinates: [number, number][][];
-        }, {
-            type: "Polygon";
-            coordinates: [number, number][][];
-        }>]>;
-    }, "strip", z.ZodTypeAny, {
-        type: "Feature";
-        geometry: {
-            type: "LineString";
-            coordinates: [number, number][];
-        } | {
-            type: "Polygon";
-            coordinates: [number, number][][];
-        };
-        properties: {
-            contour: number;
-            fill?: string | undefined;
-            color?: string | undefined;
-            opacity?: number | undefined;
-            'fill-opacity'?: number | undefined;
-            fillColor?: string | undefined;
-            fillOpacity?: number | undefined;
-            metric?: "time" | "distance" | undefined;
-        };
-    }, {
-        type: "Feature";
-        geometry: {
-            type: "LineString";
-            coordinates: [number, number][];
-        } | {
-            type: "Polygon";
-            coordinates: [number, number][][];
-        };
-        properties: {
-            contour: number;
-            fill?: string | undefined;
-            color?: string | undefined;
-            opacity?: number | undefined;
-            'fill-opacity'?: number | undefined;
-            fillColor?: string | undefined;
-            fillOpacity?: number | undefined;
-            metric?: "time" | "distance" | undefined;
-        };
-    }>, "many">;
-}, "strip", z.ZodTypeAny, {
-    type: "FeatureCollection";
-    features: {
-        type: "Feature";
-        geometry: {
-            type: "LineString";
-            coordinates: [number, number][];
-        } | {
-            type: "Polygon";
-            coordinates: [number, number][][];
-        };
-        properties: {
-            contour: number;
-            fill?: string | undefined;
-            color?: string | undefined;
-            opacity?: number | undefined;
-            'fill-opacity'?: number | undefined;
-            fillColor?: string | undefined;
-            fillOpacity?: number | undefined;
-            metric?: "time" | "distance" | undefined;
-        };
-    }[];
-}, {
-    type: "FeatureCollection";
-    features: {
-        type: "Feature";
-        geometry: {
-            type: "LineString";
-            coordinates: [number, number][];
-        } | {
-            type: "Polygon";
-            coordinates: [number, number][][];
-        };
-        properties: {
-            contour: number;
-            fill?: string | undefined;
-            color?: string | undefined;
-            opacity?: number | undefined;
-            'fill-opacity'?: number | undefined;
-            fillColor?: string | undefined;
-            fillOpacity?: number | undefined;
-            metric?: "time" | "distance" | undefined;
-        };
-    }[];
-}>;
+            coordinates: z.ZodArray<z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>>;
+        }, z.core.$strip>]>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
 export type IsochroneResponse = z.infer<typeof IsochroneResponseSchema>;
 export type IsochroneFeature = z.infer<typeof IsochroneFeatureSchema>;
 export type IsochroneGeometry = z.infer<typeof IsochroneGeometrySchema>;

package/dist/esm/tools/isochrone-tool/IsochroneTool.output.schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"IsochroneTool.output.schema.d.ts","sourceRoot":"","sources":["../../../../src/tools/isochrone-tool/IsochroneTool.output.schema.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;;GAGG;AACH,eAAO,MAAM,gCAAgC;IAC3C,2FAA2F;;IAE3F,oEAAoE;;IAEpE,sEAAsE;;IAEtE,6FAA6F;;IAE7F,+FAA+F;;IAE/F,0FAA0F;;IAE1F,4FAA4F;;IAE5F,2EAA2E;;;;;;;;;;;;;;;;;;;;EAE3E,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;IASlC,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,sBAAsB;;;QAnCjC,2FAA2F;;QAE3F,oEAAoE;;QAEpE,sEAAsE;;QAEtE,6FAA6F;;QAE7F,+FAA+F;;QAE/F,0FAA0F;;QAE1F,4FAA4F;;QAE5F,2EAA2E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAyB3E,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,uBAAuB;;;;;YA7ClC,2FAA2F;;YAE3F,oEAAoE;;YAEpE,sEAAsE;;YAEtE,6FAA6F;;YAE7F,+FAA+F;;YAE/F,0FAA0F;;YAE1F,4FAA4F;;YAE5F,2EAA2E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAkC3E,CAAC;AAEH,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AACxE,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AACtE,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AACxE,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,KAAK,CAC9C,OAAO,gCAAgC,CACxC,CAAC"}
+{"version":3,"file":"IsochroneTool.output.schema.d.ts","sourceRoot":"","sources":["../../../../src/tools/isochrone-tool/IsochroneTool.output.schema.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;;GAGG;AACH,eAAO,MAAM,gCAAgC;;;;;;;;;;;;iBAiB3C,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,uBAAuB;;;;;;mBASlC,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;iBAIjC,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;iBAGlC,CAAC;AAEH,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AACxE,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AACtE,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AACxE,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,KAAK,CAC9C,OAAO,gCAAgC,CACxC,CAAC"}

package/dist/esm/tools/length-tool/LengthTool.d.ts

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

package/dist/esm/tools/length-tool/LengthTool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LengthTool.d.ts","sourceRoot":"","sources":["../../../../src/tools/length-tool/LengthTool.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAC1C,OAAO,EAAE,iBAAiB,EAAE,MAAM,8BAA8B,CAAC;AACjE,OAAO,EACL,kBAAkB,EAEnB,MAAM,+BAA+B,CAAC;AACvC,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oCAAoC,CAAC;AAEzE,qBAAa,UAAW,SAAQ,QAAQ,CACtC,OAAO,iBAAiB,EACxB,OAAO,kBAAkB,CAC1B;IACC,QAAQ,CAAC,IAAI,iBAAiB;IAC9B,QAAQ,CAAC,WAAW,SAIiB;IAErC,QAAQ,CAAC,WAAW;;;;;;MAMlB;;IAMI,GAAG,CAAC,QAAQ,EAAE,OAAO,GAAG,OAAO,CAAC,cAAc,CAAC;CAiDtD"}

package/dist/esm/tools/length-tool/LengthTool.input.schema.d.ts

@@ -0,0 +1,12 @@
+import { z } from 'zod';
+export declare const LengthInputSchema: z.ZodObject<{
+    coordinates: z.ZodArray<z.ZodArray<z.ZodNumber>>;
+    units: z.ZodDefault<z.ZodEnum<{
+        kilometers: "kilometers";
+        miles: "miles";
+        meters: "meters";
+        feet: "feet";
+    }>>;
+}, z.core.$strip>;
+export type LengthInput = z.infer<typeof LengthInputSchema>;
+//# sourceMappingURL=LengthTool.input.schema.d.ts.map

package/dist/esm/tools/length-tool/LengthTool.input.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LengthTool.input.schema.d.ts","sourceRoot":"","sources":["../../../../src/tools/length-tool/LengthTool.input.schema.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAOxB,eAAO,MAAM,iBAAiB;;;;;;;;iBAU5B,CAAC;AAEH,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC"}

package/dist/esm/tools/length-tool/LengthTool.input.schema.js

@@ -0,0 +1,18 @@
+// Copyright (c) Mapbox, Inc.
+// Licensed under the MIT License.
+import { z } from 'zod';
+const CoordinateSchema = z
+    .array(z.number())
+    .length(2)
+    .describe('Coordinate as [longitude, latitude]');
+export const LengthInputSchema = z.object({
+    coordinates: z
+        .array(CoordinateSchema)
+        .min(2)
+        .describe('LineString coordinates as [longitude, latitude] pairs'),
+    units: z
+        .enum(['kilometers', 'miles', 'meters', 'feet'])
+        .default('meters')
+        .describe('Units for the length measurement')
+});
+//# sourceMappingURL=LengthTool.input.schema.js.map

package/dist/esm/tools/length-tool/LengthTool.input.schema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"LengthTool.input.schema.js","sourceRoot":"","sources":["../../../../src/tools/length-tool/LengthTool.input.schema.ts"],"names":[],"mappings":"AAAA,6BAA6B;AAC7B,kCAAkC;AAElC,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,MAAM,gBAAgB,GAAG,CAAC;KACvB,KAAK,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC;KACjB,MAAM,CAAC,CAAC,CAAC;KACT,QAAQ,CAAC,qCAAqC,CAAC,CAAC;AAEnD,MAAM,CAAC,MAAM,iBAAiB,GAAG,CAAC,CAAC,MAAM,CAAC;IACxC,WAAW,EAAE,CAAC;SACX,KAAK,CAAC,gBAAgB,CAAC;SACvB,GAAG,CAAC,CAAC,CAAC;SACN,QAAQ,CAAC,uDAAuD,CAAC;IAEpE,KAAK,EAAE,CAAC;SACL,IAAI,CAAC,CAAC,YAAY,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,CAAC,CAAC;SAC/C,OAAO,CAAC,QAAQ,CAAC;SACjB,QAAQ,CAAC,kCAAkC,CAAC;CAChD,CAAC,CAAC"}

package/dist/esm/tools/length-tool/LengthTool.js

@@ -0,0 +1,65 @@
+// Copyright (c) Mapbox, Inc.
+// Licensed under the MIT License.
+import { length as turfLength, lineString } from '@turf/turf';
+import { context, SpanStatusCode, trace } from '@opentelemetry/api';
+import { createLocalToolExecutionContext } from '../../utils/tracing.js';
+import { BaseTool } from '../BaseTool.js';
+import { LengthInputSchema } from './LengthTool.input.schema.js';
+import { LengthOutputSchema } from './LengthTool.output.schema.js';
+export class LengthTool extends BaseTool {
+    name = 'length_tool';
+    description = 'Measure the total length of a line defined by a series of coordinates. ' +
+        'Useful for measuring a drawn route, path, or boundary without a routing API call. ' +
+        'Supports kilometers, miles, meters, and feet. ' +
+        'Works offline without API calls.';
+    annotations = {
+        title: 'Measure Line Length',
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false
+    };
+    constructor() {
+        super({ inputSchema: LengthInputSchema, outputSchema: LengthOutputSchema });
+    }
+    async run(rawInput) {
+        const toolContext = createLocalToolExecutionContext(this.name, 0);
+        return await context.with(trace.setSpan(context.active(), toolContext.span), async () => {
+            try {
+                const input = LengthInputSchema.parse(rawInput);
+                const line = lineString(input.coordinates);
+                const len = turfLength(line, { units: input.units });
+                const output = {
+                    length: Math.round(len * 1000) / 1000,
+                    units: input.units,
+                    num_coordinates: input.coordinates.length
+                };
+                const validated = this.validateOutput(output);
+                const text = `Length: ${validated.length} ${validated.units}\n` +
+                    `Coordinates: ${validated.num_coordinates} points`;
+                toolContext.span.setStatus({ code: 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: SpanStatusCode.ERROR,
+                    message: errorMessage
+                });
+                toolContext.span.end();
+                return {
+                    content: [
+                        { type: 'text', text: `LengthTool: ${errorMessage}` }
+                    ],
+                    isError: true
+                };
+            }
+        });
+    }
+}
+//# sourceMappingURL=LengthTool.js.map

package/dist/esm/tools/length-tool/LengthTool.js.map

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

package/dist/esm/tools/length-tool/LengthTool.output.schema.d.ts

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+export declare const LengthOutputSchema: z.ZodObject<{
+    length: z.ZodNumber;
+    units: z.ZodString;
+    num_coordinates: z.ZodNumber;
+}, z.core.$strip>;
+export type LengthOutput = z.infer<typeof LengthOutputSchema>;
+//# sourceMappingURL=LengthTool.output.schema.d.ts.map

package/dist/esm/tools/length-tool/LengthTool.output.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LengthTool.output.schema.d.ts","sourceRoot":"","sources":["../../../../src/tools/length-tool/LengthTool.output.schema.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,kBAAkB;;;;iBAM7B,CAAC;AAEH,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC"}

package/dist/esm/tools/length-tool/LengthTool.output.schema.js

@@ -0,0 +1,11 @@
+// Copyright (c) Mapbox, Inc.
+// Licensed under the MIT License.
+import { z } from 'zod';
+export const LengthOutputSchema = z.object({
+    length: z.number().describe('Total length of the line'),
+    units: z.string().describe('Units of measurement'),
+    num_coordinates: z
+        .number()
+        .describe('Number of coordinate points in the line')
+});
+//# sourceMappingURL=LengthTool.output.schema.js.map

package/dist/esm/tools/length-tool/LengthTool.output.schema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"LengthTool.output.schema.js","sourceRoot":"","sources":["../../../../src/tools/length-tool/LengthTool.output.schema.ts"],"names":[],"mappings":"AAAA,6BAA6B;AAC7B,kCAAkC;AAElC,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,MAAM,CAAC,MAAM,kBAAkB,GAAG,CAAC,CAAC,MAAM,CAAC;IACzC,MAAM,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,CAAC,0BAA0B,CAAC;IACvD,KAAK,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,CAAC,sBAAsB,CAAC;IAClD,eAAe,EAAE,CAAC;SACf,MAAM,EAAE;SACR,QAAQ,CAAC,yCAAyC,CAAC;CACvD,CAAC,CAAC"}

package/dist/esm/tools/map-matching-tool/MapMatchingTool.input.schema.d.ts

@@ -3,41 +3,31 @@ export declare const MapMatchingInputSchema: 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.ZodDefault<z.ZodEnum<["driving", "driving-traffic", "walking", "cycling"]>>;
-    timestamps: z.ZodOptional<z.ZodArray<z.ZodNumber, "many">>;
-    radiuses: z.ZodOptional<z.ZodArray<z.ZodNumber, "many">>;
-    annotations: z.ZodOptional<z.ZodArray<z.ZodEnum<["speed", "distance", "duration", "congestion"]>, "many">>;
-    overview: z.ZodDefault<z.ZodEnum<["full", "simplified", "false"]>>;
-    geometries: z.ZodDefault<z.ZodEnum<["geojson", "polyline", "polyline6"]>>;
-}, "strip", z.ZodTypeAny, {
-    coordinates: {
-        longitude: number;
-        latitude: number;
-    }[];
-    geometries: "geojson" | "polyline" | "polyline6";
-    overview: "false" | "simplified" | "full";
-    profile: "driving" | "driving-traffic" | "walking" | "cycling";
-    annotations?: ("duration" | "distance" | "speed" | "congestion")[] | undefined;
-    timestamps?: number[] | undefined;
-    radiuses?: number[] | undefined;
-}, {
-    coordinates: {
-        longitude: number;
-        latitude: number;
-    }[];
-    annotations?: ("duration" | "distance" | "speed" | "congestion")[] | undefined;
-    geometries?: "geojson" | "polyline" | "polyline6" | undefined;
-    overview?: "false" | "simplified" | "full" | undefined;
-    profile?: "driving" | "driving-traffic" | "walking" | "cycling" | undefined;
-    timestamps?: number[] | undefined;
-    radiuses?: number[] | undefined;
-}>;
+    }, z.core.$strip>>;
+    profile: z.ZodDefault<z.ZodEnum<{
+        driving: "driving";
+        "driving-traffic": "driving-traffic";
+        walking: "walking";
+        cycling: "cycling";
+    }>>;
+    timestamps: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+    radiuses: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+    annotations: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        duration: "duration";
+        distance: "distance";
+        speed: "speed";
+        congestion: "congestion";
+    }>>>;
+    overview: z.ZodDefault<z.ZodEnum<{
+        false: "false";
+        simplified: "simplified";
+        full: "full";
+    }>>;
+    geometries: z.ZodDefault<z.ZodEnum<{
+        geojson: "geojson";
+        polyline: "polyline";
+        polyline6: "polyline6";
+    }>>;
+}, z.core.$strip>;
 export type MapMatchingInput = z.infer<typeof MapMatchingInputSchema>;
 //# sourceMappingURL=MapMatchingTool.input.schema.d.ts.map

package/dist/esm/tools/map-matching-tool/MapMatchingTool.input.schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"MapMatchingTool.input.schema.d.ts","sourceRoot":"","sources":["../../../../src/tools/map-matching-tool/MapMatchingTool.input.schema.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiEjC,CAAC;AAEH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC"}
+{"version":3,"file":"MapMatchingTool.input.schema.d.ts","sourceRoot":"","sources":["../../../../src/tools/map-matching-tool/MapMatchingTool.input.schema.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAiEjC,CAAC;AAEH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC"}