mcp-travelcode 1.0.0

package/build/http-server.js

@@ -0,0 +1,164 @@
+#!/usr/bin/env node
+/**
+ * HTTP entry point for the TravelCode MCP Server.
+ *
+ * Supports OAuth 2.1 via MCP spec:
+ * - Serves Protected Resource Metadata (RFC 9728) at /.well-known/oauth-protected-resource
+ * - Returns 401 with WWW-Authenticate header when Bearer token is missing
+ * - Creates per-session McpServer instances using the user's OAuth token
+ *
+ * The Authorization Server is TravelCode's own OAuth server.
+ * Tokens are opaque and validated by TravelCode API on each request.
+ *
+ * Stdio transport (src/index.ts) remains unchanged for backward compatibility.
+ */
+import express from "express";
+import { randomUUID } from "node:crypto";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import { createServer } from "./server.js";
+// --- Configuration ---
+const PORT = parseInt(process.env.PORT || "3000", 10);
+const API_BASE_URL = (process.env.TRAVELCODE_API_BASE_URL || "https://api.travel-code.com/v1").replace(/\/+$/, "");
+const OAUTH_ISSUER = process.env.OAUTH_ISSUER || "https://travel-code.com";
+// Resource URI — the public URL of this MCP server.
+// In production, set to the actual public URL (e.g. https://mcp.travel-code.com).
+// Locally defaults to http://localhost:PORT.
+const RESOURCE_URI = process.env.RESOURCE_URI || `http://localhost:${PORT}`;
+const POLL_INTERVAL_MS = parseInt(process.env.TRAVELCODE_POLL_INTERVAL_MS || "2000", 10);
+const POLL_TIMEOUT_MS = parseInt(process.env.TRAVELCODE_POLL_TIMEOUT_MS || "90000", 10);
+const SCOPES_SUPPORTED = [
+    "flights:search",
+    "flights:status",
+    "flights:stats",
+    "airports:read",
+    "airlines:read",
+    "orders:read",
+    "orders:write",
+];
+const sessions = new Map();
+// Cleanup stale sessions every 30 minutes
+const SESSION_TTL_MS = 2 * 60 * 60 * 1000; // 2 hours
+setInterval(() => {
+    const now = Date.now();
+    for (const [id, session] of sessions) {
+        if (now - session.createdAt > SESSION_TTL_MS) {
+            session.transport.close().catch(() => { });
+            session.server.close().catch(() => { });
+            sessions.delete(id);
+        }
+    }
+}, 30 * 60 * 1000);
+// --- Express app ---
+const app = express();
+app.use(express.json());
+// CORS — needed for browser-based MCP clients
+app.use((_req, res, next) => {
+    res.setHeader("Access-Control-Allow-Origin", "*");
+    res.setHeader("Access-Control-Allow-Methods", "GET, POST, DELETE, OPTIONS");
+    res.setHeader("Access-Control-Allow-Headers", "Content-Type, Authorization, Mcp-Session-Id");
+    res.setHeader("Access-Control-Expose-Headers", "Mcp-Session-Id");
+    next();
+});
+app.options("*", (_req, res) => {
+    res.sendStatus(204);
+});
+// --- Protected Resource Metadata (RFC 9728) ---
+app.get("/.well-known/oauth-protected-resource", (_req, res) => {
+    res.json({
+        resource: RESOURCE_URI,
+        authorization_servers: [OAUTH_ISSUER],
+        scopes_supported: SCOPES_SUPPORTED,
+        bearer_methods_supported: ["header"],
+        resource_name: "TravelCode MCP Server",
+    });
+});
+// --- Health check ---
+app.get("/health", (_req, res) => {
+    res.json({
+        status: "ok",
+        transport: "streamable-http",
+        sessions: sessions.size,
+    });
+});
+// --- Helper: send 401 ---
+function send401(res) {
+    const metadataUrl = `${RESOURCE_URI}/.well-known/oauth-protected-resource`;
+    res.status(401)
+        .set("WWW-Authenticate", `Bearer resource_metadata="${metadataUrl}"`)
+        .json({ error: "unauthorized", error_description: "Bearer token required" });
+}
+// --- MCP endpoint ---
+app.all("/mcp", async (req, res) => {
+    // 1. Extract Bearer token
+    const authHeader = req.headers.authorization;
+    if (!authHeader || !authHeader.startsWith("Bearer ")) {
+        send401(res);
+        return;
+    }
+    const token = authHeader.substring(7).trim();
+    if (!token) {
+        send401(res);
+        return;
+    }
+    // 2. Route to existing session or create new
+    const sessionId = req.headers["mcp-session-id"];
+    if (sessionId) {
+        const session = sessions.get(sessionId);
+        if (!session) {
+            res.status(404).json({
+                jsonrpc: "2.0",
+                error: { code: -32000, message: "Session not found. Please start a new session." },
+            });
+            return;
+        }
+        await session.transport.handleRequest(req, res, req.body);
+        return;
+    }
+    // 3. New session — only via POST (initialization)
+    if (req.method !== "POST") {
+        res.status(400).json({
+            jsonrpc: "2.0",
+            error: { code: -32000, message: "Missing Mcp-Session-Id header. Initialize session with POST first." },
+        });
+        return;
+    }
+    // Create per-session config with user's OAuth token
+    const config = {
+        apiBaseUrl: API_BASE_URL,
+        apiToken: token,
+        pollIntervalMs: POLL_INTERVAL_MS,
+        pollTimeoutMs: POLL_TIMEOUT_MS,
+    };
+    const server = createServer(config);
+    const transport = new StreamableHTTPServerTransport({
+        sessionIdGenerator: () => randomUUID(),
+    });
+    transport.onclose = () => {
+        const sid = transport.sessionId;
+        if (sid) {
+            sessions.delete(sid);
+        }
+    };
+    await server.connect(transport);
+    // Store session
+    const sid = transport.sessionId;
+    if (sid) {
+        sessions.set(sid, {
+            transport,
+            server,
+            createdAt: Date.now(),
+        });
+    }
+    // Handle the initialization request
+    await transport.handleRequest(req, res, req.body);
+});
+// --- Start ---
+app.listen(PORT, () => {
+    console.log(`TravelCode MCP Server (HTTP) listening on port ${PORT}`);
+    console.log(`MCP endpoint:        ${RESOURCE_URI}/mcp`);
+    console.log(`Resource metadata:   ${RESOURCE_URI}/.well-known/oauth-protected-resource`);
+    console.log(`OAuth issuer:        ${OAUTH_ISSUER}`);
+    console.log(`API base URL:        ${API_BASE_URL}`);
+    console.log(`Scopes:              ${SCOPES_SUPPORTED.join(", ")}`);
+});
+//# sourceMappingURL=http-server.js.map

package/build/index.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=index.d.ts.map

package/build/index.js

@@ -0,0 +1,16 @@
+#!/usr/bin/env node
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { loadConfig } from "./config.js";
+import { createServer } from "./server.js";
+async function main() {
+    const config = await loadConfig();
+    const server = createServer(config);
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error("TravelCode MCP Server running on stdio");
+}
+main().catch((error) => {
+    console.error("Fatal error:", error.message);
+    process.exit(1);
+});
+//# sourceMappingURL=index.js.map

package/build/polling/flight-poller.d.ts

@@ -0,0 +1,11 @@
+import { TravelCodeApiClient } from "../client/api-client.js";
+import { TravelCodeConfig } from "../config.js";
+import { FlightSearchRequest, FlightSearchResultsResponse } from "../client/types.js";
+export interface FlightSearchResult {
+    cacheId: string;
+    completed: boolean;
+    response: FlightSearchResultsResponse;
+}
+export type ProgressCallback = (progress: number, total: number, message: string) => Promise<void>;
+export declare function executeFlightSearch(client: TravelCodeApiClient, searchParams: FlightSearchRequest, config: TravelCodeConfig, onProgress?: ProgressCallback): Promise<FlightSearchResult>;
+//# sourceMappingURL=flight-poller.d.ts.map

package/build/polling/flight-poller.js

@@ -0,0 +1,60 @@
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+export async function executeFlightSearch(client, searchParams, config, onProgress) {
+    // Step 1: Create the search
+    await onProgress?.(0, 100, "Submitting search request...");
+    const createResponse = await client.post("/search/flights", searchParams);
+    const cacheId = createResponse.cacheId;
+    if (!cacheId) {
+        throw new Error("No cacheId returned from flight search creation");
+    }
+    // Step 2: Poll for results
+    const startTime = Date.now();
+    let interval = config.pollIntervalMs;
+    const maxInterval = Math.max(config.pollIntervalMs * 2.5, 5000);
+    let pollAttempt = 0;
+    await onProgress?.(10, 100, "Waiting for airline responses...");
+    while (true) {
+        await sleep(interval);
+        pollAttempt++;
+        const elapsed = Date.now() - startTime;
+        // Progress: 10-90% mapped to elapsed/timeout ratio
+        const progressPct = Math.min(10 + Math.round((elapsed / config.pollTimeoutMs) * 80), 90);
+        if (elapsed >= config.pollTimeoutMs) {
+            await onProgress?.(90, 100, "Timeout — fetching partial results...");
+            const partialResults = await client.get(`/search/flights/${encodeURIComponent(cacheId)}`, {
+                limit: 25,
+                offset: 0,
+                sort: "price",
+                sortOrder: "ASC",
+                embedded: "airlines,dictionaries",
+            });
+            return {
+                cacheId,
+                completed: false,
+                response: partialResults,
+            };
+        }
+        const results = await client.get(`/search/flights/${encodeURIComponent(cacheId)}`, {
+            limit: 25,
+            offset: 0,
+            sort: "price",
+            sortOrder: "ASC",
+            embedded: "airlines,dictionaries",
+        });
+        const foundCount = results.total ?? 0;
+        await onProgress?.(progressPct, 100, `Polling airlines... ${foundCount} flights found so far (attempt ${pollAttempt})`);
+        if (results.completed || results.status === "completed") {
+            await onProgress?.(100, 100, `Search complete — ${foundCount} flights found`);
+            return {
+                cacheId,
+                completed: true,
+                response: results,
+            };
+        }
+        // Exponential backoff
+        interval = Math.min(interval * 1.5, maxInterval);
+    }
+}
+//# sourceMappingURL=flight-poller.js.map

package/build/server.d.ts

@@ -0,0 +1,4 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { TravelCodeConfig } from "./config.js";
+export declare function createServer(config: TravelCodeConfig): McpServer;
+//# sourceMappingURL=server.d.ts.map

package/build/server.js

@@ -0,0 +1,54 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { TravelCodeApiClient } from "./client/api-client.js";
+import { registerSearchAirports } from "./tools/search-airports.js";
+import { registerGetAirport } from "./tools/get-airport.js";
+import { registerSearchAirlines } from "./tools/search-airlines.js";
+import { registerSearchFlights } from "./tools/search-flights.js";
+import { registerGetFlightResults } from "./tools/get-flight-results.js";
+import { registerGetFlightStatus } from "./tools/get-flight-status.js";
+import { registerGetAirportFlights } from "./tools/get-airport-flights.js";
+import { registerGetFlightDelayStats } from "./tools/get-flight-delay-stats.js";
+import { registerGetAirportDelayStats } from "./tools/get-airport-delay-stats.js";
+import { registerListOrders } from "./tools/list-orders.js";
+import { registerGetOrder } from "./tools/get-order.js";
+import { registerCreateOrder } from "./tools/create-order.js";
+import { registerCheckOrderCancellation } from "./tools/check-order-cancellation.js";
+import { registerCancelOrder } from "./tools/cancel-order.js";
+import { registerCheckOrderModification } from "./tools/check-order-modification.js";
+import { registerModifyOrder } from "./tools/modify-order.js";
+import { registerSearchHotelLocations } from "./tools/search-hotel-locations.js";
+import { registerGetHotelLocation } from "./tools/get-hotel-location.js";
+import { registerSearchHotels } from "./tools/search-hotels.js";
+export function createServer(config) {
+    const server = new McpServer({
+        name: "TravelCode",
+        version: "1.0.0",
+    });
+    const client = new TravelCodeApiClient(config);
+    // Reference data tools
+    registerSearchAirports(server, client);
+    registerGetAirport(server, client);
+    registerSearchAirlines(server, client);
+    // Flight search tools
+    registerSearchFlights(server, client, config);
+    registerGetFlightResults(server, client);
+    // Flight statistics tools (AeroDataBox)
+    registerGetFlightStatus(server, client);
+    registerGetAirportFlights(server, client);
+    registerGetFlightDelayStats(server, client);
+    registerGetAirportDelayStats(server, client);
+    // Order management tools
+    registerListOrders(server, client);
+    registerGetOrder(server, client);
+    registerCreateOrder(server, client);
+    registerCheckOrderCancellation(server, client);
+    registerCancelOrder(server, client);
+    registerCheckOrderModification(server, client);
+    registerModifyOrder(server, client);
+    // Hotel search tools
+    registerSearchHotelLocations(server, client);
+    registerGetHotelLocation(server, client);
+    registerSearchHotels(server, client);
+    return server;
+}
+//# sourceMappingURL=server.js.map

package/build/tools/cancel-order.d.ts

@@ -0,0 +1,9 @@
+import { z } from "zod";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { TravelCodeApiClient } from "../client/api-client.js";
+export declare const cancelOrderSchema: {
+    order_id: z.ZodNumber;
+    reason: z.ZodOptional<z.ZodString>;
+};
+export declare function registerCancelOrder(server: McpServer, client: TravelCodeApiClient): void;
+//# sourceMappingURL=cancel-order.d.ts.map

package/build/tools/cancel-order.js

@@ -0,0 +1,24 @@
+import { z } from "zod";
+import { formatCancelResult } from "../formatters/order-formatter.js";
+export const cancelOrderSchema = {
+    order_id: z.number().int().describe("Order ID to cancel"),
+    reason: z.string().optional().describe("Reason for cancellation"),
+};
+export function registerCancelOrder(server, client) {
+    server.tool("cancel_order", "Cancel an order. Cancellation is asynchronous — use get_order to poll for final status. It is recommended to call check_order_cancellation first to verify conditions. Idempotent: calling on an already cancelled order returns current status.", cancelOrderSchema, async ({ order_id, reason }) => {
+        try {
+            const body = reason ? { reason } : undefined;
+            const data = await client.post(`/orders/${order_id}/cancel`, body);
+            return {
+                content: [{ type: "text", text: formatCancelResult(data) }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: `Error cancelling order ${order_id}: ${error.message}` }],
+                isError: true,
+            };
+        }
+    });
+}
+//# sourceMappingURL=cancel-order.js.map

package/build/tools/check-order-cancellation.d.ts

@@ -0,0 +1,8 @@
+import { z } from "zod";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { TravelCodeApiClient } from "../client/api-client.js";
+export declare const checkOrderCancellationSchema: {
+    order_id: z.ZodNumber;
+};
+export declare function registerCheckOrderCancellation(server: McpServer, client: TravelCodeApiClient): void;
+//# sourceMappingURL=check-order-cancellation.d.ts.map

package/build/tools/check-order-cancellation.js

@@ -0,0 +1,22 @@
+import { z } from "zod";
+import { formatCancelCheck } from "../formatters/order-formatter.js";
+export const checkOrderCancellationSchema = {
+    order_id: z.number().int().describe("Order ID to check cancellation for"),
+};
+export function registerCheckOrderCancellation(server, client) {
+    server.tool("check_order_cancellation", "Check if an order can be cancelled and what the refund conditions are (penalty, deadline, estimated refund amount). Always call this before cancel_order.", checkOrderCancellationSchema, async ({ order_id }) => {
+        try {
+            const data = await client.get(`/orders/${order_id}/cancel/check`);
+            return {
+                content: [{ type: "text", text: formatCancelCheck(data, order_id) }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: `Error checking cancellation for order ${order_id}: ${error.message}` }],
+                isError: true,
+            };
+        }
+    });
+}
+//# sourceMappingURL=check-order-cancellation.js.map

package/build/tools/check-order-modification.d.ts

@@ -0,0 +1,8 @@
+import { z } from "zod";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { TravelCodeApiClient } from "../client/api-client.js";
+export declare const checkOrderModificationSchema: {
+    order_id: z.ZodNumber;
+};
+export declare function registerCheckOrderModification(server: McpServer, client: TravelCodeApiClient): void;
+//# sourceMappingURL=check-order-modification.d.ts.map

package/build/tools/check-order-modification.js

@@ -0,0 +1,22 @@
+import { z } from "zod";
+import { formatModifyCheck } from "../formatters/order-formatter.js";
+export const checkOrderModificationSchema = {
+    order_id: z.number().int().describe("Order ID to check modification for"),
+};
+export function registerCheckOrderModification(server, client) {
+    server.tool("check_order_modification", "Check if an order can be modified and what changes are allowed (contact, passport, rebook, baggage). Returns the list of services with their allowed change types. Always call this before modify_order.", checkOrderModificationSchema, async ({ order_id }) => {
+        try {
+            const data = await client.get(`/orders/${order_id}/modify/check`);
+            return {
+                content: [{ type: "text", text: formatModifyCheck(data, order_id) }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: `Error checking modification for order ${order_id}: ${error.message}` }],
+                isError: true,
+            };
+        }
+    });
+}
+//# sourceMappingURL=check-order-modification.js.map

package/build/tools/create-order.d.ts

@@ -0,0 +1,75 @@
+import { z } from "zod";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { TravelCodeApiClient } from "../client/api-client.js";
+export declare const createOrderSchema: {
+    cache_id: z.ZodString;
+    offer_id: z.ZodUnion<[z.ZodNumber, z.ZodString]>;
+    passengers: z.ZodArray<z.ZodObject<{
+        type: z.ZodOptional<z.ZodEnum<["adult", "child", "infant"]>>;
+        firstName: z.ZodString;
+        lastName: z.ZodString;
+        dateOfBirth: z.ZodString;
+        gender: z.ZodEnum<["M", "F"]>;
+        document: z.ZodOptional<z.ZodObject<{
+            type: z.ZodDefault<z.ZodEnum<["PASSPORT", "ID_CARD"]>>;
+            number: z.ZodString;
+            expiryDate: z.ZodOptional<z.ZodString>;
+            nationality: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            number: string;
+            type: "PASSPORT" | "ID_CARD";
+            expiryDate?: string | undefined;
+            nationality?: string | undefined;
+        }, {
+            number: string;
+            type?: "PASSPORT" | "ID_CARD" | undefined;
+            expiryDate?: string | undefined;
+            nationality?: string | undefined;
+        }>>;
+        contacts: z.ZodOptional<z.ZodObject<{
+            email: z.ZodOptional<z.ZodString>;
+            phone: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            email?: string | undefined;
+            phone?: string | undefined;
+        }, {
+            email?: string | undefined;
+            phone?: string | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        firstName: string;
+        lastName: string;
+        dateOfBirth: string;
+        gender: "M" | "F";
+        type?: "adult" | "child" | "infant" | undefined;
+        document?: {
+            number: string;
+            type: "PASSPORT" | "ID_CARD";
+            expiryDate?: string | undefined;
+            nationality?: string | undefined;
+        } | undefined;
+        contacts?: {
+            email?: string | undefined;
+            phone?: string | undefined;
+        } | undefined;
+    }, {
+        firstName: string;
+        lastName: string;
+        dateOfBirth: string;
+        gender: "M" | "F";
+        type?: "adult" | "child" | "infant" | undefined;
+        document?: {
+            number: string;
+            type?: "PASSPORT" | "ID_CARD" | undefined;
+            expiryDate?: string | undefined;
+            nationality?: string | undefined;
+        } | undefined;
+        contacts?: {
+            email?: string | undefined;
+            phone?: string | undefined;
+        } | undefined;
+    }>, "many">;
+    idempotency_key: z.ZodOptional<z.ZodString>;
+};
+export declare function registerCreateOrder(server: McpServer, client: TravelCodeApiClient): void;
+//# sourceMappingURL=create-order.d.ts.map

package/build/tools/create-order.js

@@ -0,0 +1,52 @@
+import { z } from "zod";
+import { formatOrderDetail } from "../formatters/order-formatter.js";
+const passengerDocumentSchema = z.object({
+    type: z.enum(["PASSPORT", "ID_CARD"]).default("PASSPORT").describe("Document type"),
+    number: z.string().describe("Document number"),
+    expiryDate: z.string().optional().describe("Expiry date (DD.MM.YYYY)"),
+    nationality: z.string().optional().describe("Country code ISO 2 (e.g. BY, RU, PL)"),
+});
+const passengerContactsSchema = z.object({
+    email: z.string().optional().describe("Email address"),
+    phone: z.string().optional().describe("Phone number with country code (e.g. +375291234567)"),
+});
+const passengerSchema = z.object({
+    type: z.enum(["adult", "child", "infant"]).optional().describe("Passenger type. If omitted, calculated from date of birth"),
+    firstName: z.string().describe("First name (Latin characters)"),
+    lastName: z.string().describe("Last name (Latin characters)"),
+    dateOfBirth: z.string().describe("Date of birth (DD.MM.YYYY)"),
+    gender: z.enum(["M", "F"]).describe("Gender"),
+    document: passengerDocumentSchema.optional().describe("Travel document details"),
+    contacts: passengerContactsSchema.optional().describe("Contact information (recommended for first passenger)"),
+});
+export const createOrderSchema = {
+    cache_id: z.string().describe("Cache ID from a previous search_flights result"),
+    offer_id: z.union([z.number(), z.string()]).describe("Offer index from the search results items array, or a specific orderId"),
+    passengers: z.array(passengerSchema).min(1).describe("Array of passenger details"),
+    idempotency_key: z.string().optional().describe("UUID for duplicate protection (recommended)"),
+};
+export function registerCreateOrder(server, client) {
+    server.tool("create_order", "Book a flight by creating an order from a search result. Requires a cache_id from search_flights, an offer_id (index in search results), and passenger details. The typical flow: search_flights → pick offer → create_order.", createOrderSchema, async ({ cache_id, offer_id, passengers, idempotency_key }) => {
+        try {
+            const extraHeaders = {};
+            if (idempotency_key) {
+                extraHeaders["Idempotency-Key"] = idempotency_key;
+            }
+            const order = await client.post("/orders", {
+                cacheId: cache_id,
+                offerId: offer_id,
+                passengers,
+            }, extraHeaders);
+            return {
+                content: [{ type: "text", text: formatOrderDetail(order) }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: `Error creating order: ${error.message}` }],
+                isError: true,
+            };
+        }
+    });
+}
+//# sourceMappingURL=create-order.js.map

package/build/tools/get-airport-delay-stats.d.ts

@@ -0,0 +1,9 @@
+import { z } from "zod";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { TravelCodeApiClient } from "../client/api-client.js";
+export declare const getAirportDelayStatsSchema: {
+    airport_code: z.ZodString;
+    date: z.ZodString;
+};
+export declare function registerGetAirportDelayStats(server: McpServer, client: TravelCodeApiClient): void;
+//# sourceMappingURL=get-airport-delay-stats.d.ts.map

package/build/tools/get-airport-delay-stats.js

@@ -0,0 +1,31 @@
+import { z } from "zod";
+import { formatAirportDelayStats } from "../formatters/aerodatabox-formatter.js";
+export const getAirportDelayStatsSchema = {
+    airport_code: z
+        .string()
+        .describe("IATA airport code (e.g. 'JFK', 'LHR', 'WAW')"),
+    date: z
+        .string()
+        .describe("Date in YYYY-MM-DD format (e.g. '2026-02-15')"),
+};
+export function registerGetAirportDelayStats(server, client) {
+    server.tool("get_airport_delay_stats", "Get current delay statistics for an airport on a specific date. Shows average departure/arrival delays and cancellation rates. Use this during weather events or disruptions to assess the situation at an airport.", getAirportDelayStatsSchema, async ({ airport_code, date }) => {
+        try {
+            const code = airport_code.toUpperCase();
+            const stats = await client.getAerodatabox(`/airports/iata/${encodeURIComponent(code)}/delays/${date}`);
+            return {
+                content: [{ type: "text", text: formatAirportDelayStats(stats, code, date) }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{
+                        type: "text",
+                        text: `Error getting delay stats for airport ${airport_code}: ${error.message}`,
+                    }],
+                isError: true,
+            };
+        }
+    });
+}
+//# sourceMappingURL=get-airport-delay-stats.js.map

package/build/tools/get-airport-flights.d.ts

@@ -0,0 +1,13 @@
+import { z } from "zod";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { TravelCodeApiClient } from "../client/api-client.js";
+export declare const getAirportFlightsSchema: {
+    airport_code: z.ZodString;
+    direction: z.ZodDefault<z.ZodEnum<["departure", "arrival"]>>;
+    from_time: z.ZodString;
+    to_time: z.ZodString;
+    include_codeshares: z.ZodDefault<z.ZodBoolean>;
+    include_cargo: z.ZodDefault<z.ZodBoolean>;
+};
+export declare function registerGetAirportFlights(server: McpServer, client: TravelCodeApiClient): void;
+//# sourceMappingURL=get-airport-flights.d.ts.map