GetProducts

Instructions

Implementation Reference

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

  This is the core handler function that implements the logic for the GetProducts tool (and all store tools). It processes the input parameters, constructs the appropriate query or body, and makes the API request to the Medusa store backend using the SDK's client.fetch method.

      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 GetProducts tool based on the OpenAPI specification parameters for the corresponding 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/index.ts:35-42 (registration)

  Registers the GetProducts tool (among others) with the MCP server by calling server.tool for each generated tool.

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

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

  Generates all store tools, including GetProducts, by iterating over OpenAPI paths and calling wrapPath to define each tool.

  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 tool handler to match MCP protocol requirements, serializes output to JSON text, and handles errors appropriately.

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