Get All Delivery Addresses

Instructions

Implementation Reference

• src/tools/addresses/getDeliveryAddresses.ts:34-107 (handler)

  The main handler function 'registerGetDeliveryAddressesTool' that registers and implements the 'getDeliveryAddresses' tool. It creates an API client, calls client.getDeliveryAddresses({all:true}), formats the response, and handles errors.

  export function registerGetDeliveryAddressesTool(server: McpServer): void {
    // Create API client instance
  
    // Register getDeliveryAddresses tool
    server.registerTool(
      "getDeliveryAddresses",
      {
        title: "Get All Delivery Addresses",
        description:
          "Retrieves all delivery addresses (destination locations) for the authenticated customer. Returns complete list with coordinates and postal codes.",
        inputSchema: {},
      },
      async () => {
        // Get API key from async context
        const apiKey = apiKeyStorage.getStore();
  
        if (!apiKey) {
          return {
            content: [
              {
                type: "text",
                text: "Error: X-API-KEY header is required",
              },
            ],
          };
        }
  
        // Create API client with customer's API key
        const client = new EuroparcelApiClient(apiKey);
  
        try {
          logger.info("Fetching all delivery addresses");
  
          const response = await client.getDeliveryAddresses({
            all: true,
          });
  
          logger.info(`Retrieved ${response.list.length} delivery addresses`);
  
          let formattedResponse = `Found ${response.meta.total} delivery address${response.meta.total !== 1 ? "es" : ""}:\n\n`;
  
          if (response.list.length === 0) {
            formattedResponse += "No delivery addresses found.";
          } else {
            response.list.forEach((address: DeliveryAddress) => {
              formattedResponse += formatAddress(address, "Delivery") + "\n";
            });
          }
  
          return {
            content: [
              {
                type: "text",
                text: formattedResponse,
              },
            ],
          };
        } catch (error: any) {
          logger.error("Failed to fetch delivery addresses", error);
  
          return {
            content: [
              {
                type: "text",
                text: `Error fetching delivery addresses: ${error.message || "Unknown error"}`,
              },
            ],
          };
        }
      },
    );
  
    logger.info("getDeliveryAddresses tool registered successfully");
  }

• src/tools/addresses/index.ts:1-21 (registration)

  Registration of the tool via registerGetDeliveryAddressesTool(server) called from the address tools aggregator module.

  import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
  import { registerGetBillingAddressesTool } from "./getBillingAddresses.js";
  import { registerGetShippingAddressesTool } from "./getShippingAddresses.js";
  import { registerGetDeliveryAddressesTool } from "./getDeliveryAddresses.js";
  import { logger } from "../../utils/logger.js";
  
  export function registerAddressTools(server: McpServer): void {
    logger.info("Registering address tools...");
  
    // Register all address-related tools
    registerGetBillingAddressesTool(server);
    registerGetShippingAddressesTool(server);
    registerGetDeliveryAddressesTool(server);
  
    logger.info("All address tools registered successfully");
  }
  
  // Export individual registration functions if needed
  export { registerGetBillingAddressesTool } from "./getBillingAddresses.js";
  export { registerGetShippingAddressesTool } from "./getShippingAddresses.js";
  export { registerGetDeliveryAddressesTool } from "./getDeliveryAddresses.js";

• src/tools/addresses/getDeliveryAddresses.ts:8-32 (helper)

  Helper function 'formatAddress' that formats a DeliveryAddress object into a human-readable string for display.

  function formatAddress(address: any, type: string): string {
    let details = `${type} Address #${address.id}:
  - Type: ${address.address_type}
  - Contact: ${address.contact}
  - Phone: ${address.phone}
  - Email: ${address.email}
  - Location: ${address.locality_name}, ${address.county_name} (${address.country_code})
  - Street: ${address.street_name || "N/A"} ${address.street_no}${address.street_details ? ", " + address.street_details : ""}`;
  
    if ((type === "Shipping" || type === "Delivery") && address.zipcode) {
      details += `
  - Zip Code: ${address.zipcode}`;
    }
  
    if ((type === "Shipping" || type === "Delivery") && address.coordinates) {
      details += `
  - Coordinates: ${address.coordinates.lat}, ${address.coordinates.lng}`;
    }
  
    details += `
  - Default: ${address.is_default ? "Yes" : "No"}
  `;
  
    return details;
  }

• src/types/index.ts:85-87 (schema)

  Type definition for DeliveryAddress interface, which extends ShippingAddress (same structure).

  export interface DeliveryAddress extends ShippingAddress {
    // Delivery addresses have the same structure as shipping addresses
  }

• src/api/client.ts:147-158 (registration)

  API client method 'getDeliveryAddresses' that makes the HTTP GET request to /addresses/delivery endpoint.

  async getDeliveryAddresses(params?: {
    page?: number;
    per_page?: 15 | 50 | 100 | 200;
    all?: boolean;
  }): Promise<PaginatedAddressResponse<DeliveryAddress>> {
    const response = await this.client.get<
      PaginatedAddressResponse<DeliveryAddress>
    >("/addresses/delivery", {
      params,
    });
    return response.data;
  }