WooCommerce

Delete a tax class

List shipping zones

Get a single shipping zone

Create a new shipping zone

Update a shipping zone

Delete a shipping zone

Get locations for a shipping zone

Update locations for a shipping zone

List methods for a shipping zone

Get a shipping zone method

Add a shipping method to a zone

Update a shipping zone method

Delete a shipping zone method

List available shipping methods

Get a shipping method

List payment gateways

Get a payment gateway

Update a payment gateway

Update a webhook

Update a setting option

Get a single setting option

Create a new product', schema: productCreateSchema, handler: async (params: z.infer<typeof productCreateSchema>) => { const result = await client.createProduct(params); return { content: [{ type: 'text' as const, text: JSON.stringify(result, null, 2) }] }; }, },

update_product: {
  description: 'Update an existing product

Delete a product

List variations for a variable product

Get a single product variation

Create a new product variation', schema: variationCreateSchema, handler: async ({ productId, ...params }: z.infer<typeof variationCreateSchema>) => { const result = await client.createVariation(productId, params as Parameters<typeof client.createVariation>[1]); return { content: [{ type: 'text' as const, text: JSON.stringify(result, null, 2) }] }; }, },

update_variation: {
  description: 'Update a product variation

Delete a product variation

List product categories', schema: paginationSchema, handler: async (params: z.infer<typeof paginationSchema>) => { const result = await client.listCategories(params); return { content: [{ type: 'text' as const, text: JSON.stringify(result, null, 2) }] }; }, },

get_category: {
  description: 'Get a single product category

List coupons with optional filtering and pagination', schema: couponFilterSchema, handler: async (params: z.infer<typeof couponFilterSchema>) => { const result = await client.listCoupons(params); return { content: [{ type: 'text' as const, text: JSON.stringify(result, null, 2) }] }; }, },

get_coupon: {
  description: 'Get a single coupon by ID

Create a new coupon', schema: couponCreateSchema, handler: async (params: z.infer<typeof couponCreateSchema>) => { const result = await client.createCoupon(params as Parameters<typeof client.createCoupon>[0]); return { content: [{ type: 'text' as const, text: JSON.stringify(result, null, 2) }] }; }, },

update_coupon: {
  description: 'Update an existing coupon

Delete a coupon

List customers with optional filtering and pagination', schema: customerFilterSchema, handler: async (params: z.infer<typeof customerFilterSchema>) => { const result = await client.listCustomers(params); return { content: [{ type: 'text' as const, text: JSON.stringify(result, null, 2) }] }; }, },

get_customer: {
  description: 'Get a single customer by ID

Create a new customer', schema: customerCreateSchema, handler: async (params: z.infer<typeof customerCreateSchema>) => { const result = await client.createCustomer(params as Parameters<typeof client.createCustomer>[0]); return { content: [{ type: 'text' as const, text: JSON.stringify(result, null, 2) }] }; }, },

update_customer: {
  description: 'Update an existing customer

Delete a customer

Get downloads for a customer

List orders with optional filtering and pagination', schema: orderFilterSchema, handler: async (params: z.infer<typeof orderFilterSchema>) => { const result = await client.listOrders(params); return { content: [{ type: 'text' as const, text: JSON.stringify(result, null, 2) }] }; }, },

get_order: {
  description: 'Get a single order by ID

Create a new order', schema: orderCreateSchema, handler: async (params: z.infer<typeof orderCreateSchema>) => { const result = await client.createOrder(params as Parameters<typeof client.createOrder>[0]); return { content: [{ type: 'text' as const, text: JSON.stringify(result, null, 2) }] }; }, },

update_order: {
  description: 'Update an existing order

Delete an order

List notes for an order

Get a single order note

Add a note to an order', schema: orderNoteCreateSchema, handler: async ({ orderId, ...params }: z.infer<typeof orderNoteCreateSchema>) => { const result = await client.createOrderNote(orderId, params); return { content: [{ type: 'text' as const, text: JSON.stringify(result, null, 2) }] }; }, },

delete_order_note: {
  description: 'Delete an order note

List refunds for an order

Get a single refund

Create a refund for an order', schema: refundCreateSchema, handler: async ({ orderId, ...params }: z.infer<typeof refundCreateSchema>) => { const result = await client.createRefund(orderId, params as Parameters<typeof client.createRefund>[1]); return { content: [{ type: 'text' as const, text: JSON.stringify(result, null, 2) }] }; }, },

delete_refund: {
  description: 'Delete a refund

List products with optional filtering and pagination', schema: productFilterSchema, handler: async (params: z.infer<typeof productFilterSchema>) => { const result = await client.listProducts(params); return { content: [{ type: 'text' as const, text: JSON.stringify(result, null, 2) }] }; }, },

get_product: {
  description: 'Get a single product by ID

List options for a setting group

Create a new product category', schema: categoryCreateSchema, handler: async (params: z.infer<typeof categoryCreateSchema>) => { const result = await client.createCategory(params); return { content: [{ type: 'text' as const, text: JSON.stringify(result, null, 2) }] }; }, },

update_category: {
  description: 'Update a product category

Delete a product category

List product tags', schema: paginationSchema, handler: async (params: z.infer<typeof paginationSchema>) => { const result = await client.listTags(params); return { content: [{ type: 'text' as const, text: JSON.stringify(result, null, 2) }] }; }, },

get_tag: {
  description: 'Get a single product tag

Create a new product tag', schema: tagCreateSchema, handler: async (params: z.infer<typeof tagCreateSchema>) => { const result = await client.createTag(params); return { content: [{ type: 'text' as const, text: JSON.stringify(result, null, 2) }] }; }, },

update_tag: {
  description: 'Update a product tag

Delete a product tag

List product attributes

Get a single product attribute

Create a new product attribute', schema: attributeCreateSchema, handler: async (params: z.infer<typeof attributeCreateSchema>) => { const result = await client.createAttribute(params); return { content: [{ type: 'text' as const, text: JSON.stringify(result, null, 2) }] }; }, },

update_attribute: {
  description: 'Update a product attribute

Delete a product attribute

List terms for a product attribute

Get a single attribute term

Create a new attribute term', schema: attributeTermCreateSchema, handler: async ({ attributeId, ...params }: z.infer<typeof attributeTermCreateSchema>) => { const result = await client.createAttributeTerm(attributeId, params); return { content: [{ type: 'text' as const, text: JSON.stringify(result, null, 2) }] }; }, },

update_attribute_term: {
  description: 'Update an attribute term

Delete an attribute term

List product reviews', schema: paginationSchema.extend({ search: z.string().optional(), product: z.number().optional().describe('Filter by product ID'), status: z.enum(['all', 'hold', 'approved', 'spam', 'trash']).optional(), }), handler: async (params: z.infer<typeof paginationSchema> & { search?: string; product?: number; status?: string }) => { const result = await client.listReviews(params as Parameters<typeof client.listReviews>[0]); return { content: [{ type: 'text' as const, text: JSON.stringify(result, null, 2) }] }; }, },

get_review: {
  description: 'Get a single product review

Create a new product review', schema: reviewCreateSchema, handler: async (params: z.infer<typeof reviewCreateSchema>) => { const result = await client.createReview(params); return { content: [{ type: 'text' as const, text: JSON.stringify(result, null, 2) }] }; }, },

update_review: {
  description: 'Update a product review

Delete a product review

List product shipping classes', schema: paginationSchema, handler: async (params: z.infer<typeof paginationSchema>) => { const result = await client.listShippingClasses(params); return { content: [{ type: 'text' as const, text: JSON.stringify(result, null, 2) }] }; }, },

get_shipping_class: {
  description: 'Get a single shipping class

Create a new shipping class', schema: shippingClassCreateSchema, handler: async (params: z.infer<typeof shippingClassCreateSchema>) => { const result = await client.createShippingClass(params); return { content: [{ type: 'text' as const, text: JSON.stringify(result, null, 2) }] }; }, },

update_shipping_class: {
  description: 'Update a shipping class

Delete a shipping class

List all setting groups

List tax rates', schema: paginationSchema, handler: async (params: z.infer<typeof paginationSchema>) => { const result = await client.listTaxRates(params); return { content: [{ type: 'text' as const, text: JSON.stringify(result, null, 2) }] }; }, },

get_tax_rate: {
  description: 'Get a single tax rate

Create a new tax rate

Update a tax rate

Delete a tax rate

List tax classes

Create a new tax class

List webhooks', schema: paginationSchema, handler: async (params: z.infer<typeof paginationSchema>) => { const result = await client.listWebhooks(params); return { content: [{ type: 'text' as const, text: JSON.stringify(result, null, 2) }] }; }, },

get_webhook: {
  description: 'Get a webhook

Create a new webhook

Delete a webhook

List available reports

Get sales report', schema: reportParamsSchema, handler: async (params: z.infer<typeof reportParamsSchema>) => { const result = await client.getSalesReport(params); return { content: [{ type: 'text' as const, text: JSON.stringify(result, null, 2) }] }; }, },

get_top_sellers_report: {
  description: 'Get top sellers report',
  schema: reportParamsSchema,
  handler: async (params: z.infer<typeof reportParamsSchema>) => {
    const result = await client.getTopSellersReport(params);
    return { content: [{ type: 'text' as const, text: JSON.stringify(result, null, 2) }] };
  },
},

// =========================================================================
// System Status
// =========================================================================
get_system_status: {
  description: 'Get system status information

List available system status tools

Run a system status tool

List continents with countries

Get a continent by code

List countries with states

Get a country by code

List available currencies

Get a currency by code

Get the store current currency

Test the connection to WooCommerce