PostShippingOptionsIdCalculate

Instructions

Implementation Reference

• src/index.ts:34-42 (registration)

  Registers all dynamically generated MCP tools from Medusa store and admin services onto the MCP server. The tool 'PostShippingOptionsIdCalculate' is registered here as part of the store tools.

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

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

  The handler function that implements the logic for the 'PostShippingOptionsIdCalculate' tool (and all store tools). It constructs query/body from input and calls the Medusa SDK to perform the API request to /shipping-options/{id}/calculate.

      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)

  Dynamically generates the Zod input schema for the tool based on the OpenAPI spec parameters for the shipping options calculate endpoint.

  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/services/medusa-store.ts:131-137 (registration)

  Generates the tool definition objects for all store API paths, including the one named 'PostShippingOptionsIdCalculate' from the store.json OpenAPI spec.

  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)

  Utility function used to define and wrap each tool handler with error handling and MCP protocol response formatting.

  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
      };
  };