GetCustomersMeAddressesAddress_id

Retrieve a specific customer address from your Medusa store. Use this tool to fetch address details, expand relations, or select specific fields for the logged-in customer.

Instructions

Retrieve an address of the logged-in customer. You can expand the address's relations or select the fields that should be returned.

Input Schema

TableJSON Schema

Name	Required	Description	Default
`address_id`	No
`fields`	No

Implementation Reference

src/services/medusa-store.ts:83-127 (handler)

The handler logic for the tool 'GetCustomersMeAddressesAddress_id'. This generic handler is used for all store endpoints and makes the HTTP request to the Medusa store API using the JS SDK based on the captured refPath (likely '/store/customers/me/addresses/{address_id}'), method, and parameters.

    handler: async (
        input: InferToolHandlerInput<any, ZodTypeAny>
    ): Promise<any> => {
        const query = new URLSearchParams(input);
        const body = Object.entries(input).reduce(
            (acc, [key, value]) => {
                if (
                    parameters.find(
                        (p) => p.name === key && p.in === "body"
                    )
                ) {
                    acc[key] = value;
                }
                return acc;
            },
            {} as Record<string, any>
        );
        if (method === "get") {
            console.error(
                `Fetching ${refPath} with GET ${query.toString()}`
            );
            const response = await this.sdk.client.fetch(refPath, {
                method: method,
                headers: {
                    "Content-Type": "application/json",
                    "Accept": "application/json",
                    "Authorization": `Bearer ${process.env.PUBLISHABLE_KEY}`
                },
                query: query
            });
            return response;
        } else {
            const response = await this.sdk.client.fetch(refPath, {
                method: method,
                headers: {
                    "Content-Type": "application/json",
                    "Accept": "application/json",
                    "Authorization": `Bearer ${process.env.PUBLISHABLE_KEY}`
                },
                body: JSON.stringify(body)
            });
            return response;
        }
    }
};

src/services/medusa-store.ts:54-82 (schema)

Generates the input validation schema using Zod based on the OpenAPI parameters for the 'GetCustomersMeAddressesAddress_id' tool.

inputSchema: {
    ...parameters
        .filter((p) => p.in != "header")
        .reduce((acc, param) => {
            switch (param.schema.type) {
                case "string":
                    acc[param.name] = z.string().optional();
                    break;
                case "number":
                    acc[param.name] = z.number().optional();
                    break;
                case "boolean":
                    acc[param.name] = z.boolean().optional();
                    break;
                case "array":
                    acc[param.name] = z
                        .array(z.string())
                        .optional();
                    break;
                case "object":
                    acc[param.name] = z.object({}).optional();
                    break;
                default:
                    acc[param.name] = z.string().optional();
            }
            return acc;
        }, {} as any)
},

src/index.ts:35-42 (registration)

Registers the tool 'GetCustomersMeAddressesAddress_id' (among others from store service) to the MCP server.

tools.forEach((tool) => {
    server.tool(
        tool.name,
        tool.description,
        tool.inputSchema,
        tool.handler
    );
});

src/services/medusa-store.ts:131-137 (registration)

Generates and returns the array of tool definitions from the store OpenAPI specification, including the one for 'GetCustomersMeAddressesAddress_id'.

defineTools(store = storeJson): any[] {
    const paths = Object.entries(store.paths) as [string, SdkRequestType][];
    const tools = paths.map(([path, refFunction]) =>
        this.wrapPath(path, refFunction)
    );
    return tools;
}

src/utils/define-tools.ts:16-60 (helper)

Helper utility that wraps the raw tool handler to make it compatible with MCP protocol, handling JSON output and errors.

export const defineTool = (
    cb: (zod: typeof z) => ToolDefinition<any, ZodAny, any>
) => {
    const tool = cb(z);

    const wrappedHandler = async (
        input: InferToolHandlerInput<Zod.ZodAny, Zod.ZodAny>,
        _: RequestHandlerExtra
    ): Promise<{
        content: CallToolResult["content"];
        isError?: boolean;
        statusCode?: number;
    }> => {
        try {
            const result = await tool.handler(input);
            return {
                content: [
                    {
                        type: "text",
                        text: JSON.stringify(result, null, 2)
                    }
                ]
            };
        } catch (error) {
            return {
                content: [
                    {
                        type: "text",
                        text: `Error: ${
                            error instanceof Error
                                ? error.message
                                : String(error)
                        }`
                    }
                ],
                isError: true
            };
        }
    };

    return {
        ...tool,
        handler: wrappedHandler
    };
};

Medusa MCP Server