discogs-mcp-server 0.1.0 → 0.2.0

package/dist/index.js

@@ -4,7 +4,7 @@ import dotenv from 'dotenv';
 import { z } from 'zod';
 
 // src/version.ts
-var VERSION = "0.1.0";
+var VERSION = "0.2.0";
 
 // src/config.ts
 dotenv.config();
@@ -167,21 +167,54 @@ var CurrencyCodeSchema = z.enum([
   "ZAR"
   // South African Rand
 ]);
-var PaginatedResponseSchema = (itemSchema, resultsFieldName) => z.object({
-  pagination: z.object({
-    page: z.number().int().min(0).optional(),
-    per_page: z.number().int().min(0).optional(),
-    pages: z.number().int().min(0),
-    items: z.number().int().min(0),
-    urls: z.object({
-      first: z.string().url().optional(),
-      prev: z.string().url().optional(),
-      next: z.string().url().optional(),
-      last: z.string().url().optional()
-    })
+var ImageSchema = z.object({
+  width: z.number().int().optional(),
+  height: z.number().int().optional(),
+  resource_url: urlOrEmptySchema(),
+  type: z.string().optional(),
+  uri: urlOrEmptySchema(),
+  uri150: urlOrEmptySchema().optional()
+});
+var FilteredResponseSchema = z.object({
+  filters: z.object({
+    applied: z.record(z.array(z.any())).default({}),
+    available: z.record(z.record(z.number().int())).default({})
   }),
+  filter_facets: z.array(
+    z.object({
+      title: z.string(),
+      id: z.string(),
+      values: z.array(
+        z.object({
+          title: z.string(),
+          value: z.string(),
+          count: z.number().int()
+        })
+      ),
+      allows_multiple_values: z.boolean()
+    })
+  )
+});
+var PaginationSchema = z.object({
+  page: z.number().int().min(0).optional(),
+  per_page: z.number().int().min(0).optional(),
+  pages: z.number().int().min(0),
+  items: z.number().int().min(0),
+  urls: z.object({
+    first: z.string().url().optional(),
+    prev: z.string().url().optional(),
+    next: z.string().url().optional(),
+    last: z.string().url().optional()
+  }).optional()
+});
+var PaginatedResponseSchema = (itemSchema, resultsFieldName) => z.object({
+  pagination: PaginationSchema,
   [resultsFieldName]: z.array(itemSchema)
 });
+var PaginatedResponseWithObjectSchema = (itemSchema, resultsFieldName) => z.object({
+  pagination: PaginationSchema,
+  [resultsFieldName]: itemSchema
+});
 var QueryParamsSchema = (validSortKeys = []) => z.object({
   // Pagination
   page: z.number().int().min(1).optional(),
@@ -190,6 +223,7 @@ var QueryParamsSchema = (validSortKeys = []) => z.object({
   sort: z.enum(validSortKeys).optional(),
   sort_order: z.enum(["asc", "desc"]).optional()
 });
+var StatusSchema = z.enum(["Accepted", "Draft", "Deleted", "Rejected"]);
 var UsernameInputSchema = z.object({
   username: z.string().min(1, "username is required")
 });
@@ -218,16 +252,7 @@ var ArtistSchema = z.object({
     })
   ).optional(),
   data_quality: z.string().optional(),
-  images: z.array(
-    z.object({
-      height: z.number().int().optional(),
-      resource_url: urlOrEmptySchema(),
-      type: z.string().optional(),
-      uri: urlOrEmptySchema(),
-      uri150: urlOrEmptySchema().optional(),
-      width: z.number().int().optional()
-    })
-  ).optional(),
+  images: z.array(ImageSchema).optional(),
   members: z.array(
     z.object({
       id: z.number(),
@@ -478,16 +503,7 @@ var LabelSchema = z.object({
   id: z.number(),
   contact_info: z.string().optional(),
   data_quality: z.string().optional(),
-  images: z.array(
-    z.object({
-      height: z.number().int().optional(),
-      resource_url: urlOrEmptySchema(),
-      type: z.string().optional(),
-      uri: urlOrEmptySchema(),
-      uri150: urlOrEmptySchema().optional(),
-      width: z.number().int().optional()
-    })
-  ).optional(),
+  images: z.array(ImageSchema).optional(),
   name: z.string(),
   parent_label: z.object({
     id: z.number(),
@@ -631,18 +647,9 @@ var ReleaseSchema = z.object({
       description: z.string().optional()
     })
   ).optional(),
-  images: z.array(
-    z.object({
-      height: z.number().int().optional(),
-      width: z.number().int().optional(),
-      resource_url: urlOrEmptySchema(),
-      type: z.string().optional(),
-      uri: urlOrEmptySchema().optional(),
-      uri150: urlOrEmptySchema().optional()
-    })
-  ).optional(),
+  images: z.array(ImageSchema).optional(),
   labels: z.array(LabelBasicSchema).optional(),
-  lowest_price: z.number().optional(),
+  lowest_price: z.number().nullable().optional(),
   master_id: z.number().optional(),
   master_url: urlOrEmptySchema().optional(),
   notes: z.string().optional(),
@@ -700,6 +707,12 @@ var ReleaseRatingEditParamsSchema = ReleaseRatingParamsSchema.extend({
 var MasterReleaseIdParamSchema = z.object({
   master_id: z.number().int()
 });
+var MasterReleaseVersionsParamSchema = MasterReleaseIdParamSchema.extend({
+  format: z.string().optional(),
+  label: z.string().optional(),
+  released: z.string().optional(),
+  country: z.string().optional()
+}).merge(QueryParamsSchema(["released", "title", "format", "label", "catno", "country"]));
 var MasterReleaseSchema = ReleaseSchema.extend({
   main_release: z.number(),
   most_recent_release: z.number(),
@@ -721,6 +734,33 @@ var MasterReleaseSchema = ReleaseSchema.extend({
     })
   )
 });
+var MasterReleaseVersionItemSchema = z.object({
+  id: z.number().int(),
+  label: z.string(),
+  country: z.string(),
+  title: z.string(),
+  major_formats: z.array(z.string()),
+  format: z.string(),
+  catno: z.string(),
+  released: z.string(),
+  status: StatusSchema,
+  resource_url: urlOrEmptySchema(),
+  thumb: urlOrEmptySchema().optional(),
+  stats: z.object({
+    community: z.object({
+      in_wantlist: z.number().int(),
+      in_collection: z.number().int()
+    }).optional(),
+    user: z.object({
+      in_wantlist: z.number().int(),
+      in_collection: z.number().int()
+    }).optional()
+  })
+});
+var MasterReleaseVersionsResponseSchema = z.object({
+  ...PaginatedResponseSchema(MasterReleaseVersionItemSchema, "versions").shape,
+  ...FilteredResponseSchema.shape
+});
 
 // src/services/master.ts
 var MasterReleaseService = class extends DiscogsService {
@@ -747,6 +787,31 @@ var MasterReleaseService = class extends DiscogsService {
       throw new Error(`Failed to get master release: ${String(error)}`);
     }
   }
+  /**
+   * Retrieves a list of all Releases that are versions of this master
+   *
+   * @param params - Parameters containing the master release ID and optional query parameters
+   * @returns {MasterReleaseVersionsResponse} The master release versions information
+   * @throws {DiscogsResourceNotFoundError} If the master release versions cannot be found
+   * @throws {Error} If there's an unexpected error
+   */
+  async getVersions({
+    master_id,
+    ...options
+  }) {
+    try {
+      const response = await this.request(`/${master_id}/versions`, {
+        params: options
+      });
+      const validatedResponse = MasterReleaseVersionsResponseSchema.parse(response);
+      return validatedResponse;
+    } catch (error) {
+      if (isDiscogsError(error)) {
+        throw error;
+      }
+      throw new Error(`Failed to get master release versions: ${String(error)}`);
+    }
+  }
 };
 
 // src/services/release.ts
@@ -967,6 +1032,20 @@ var getMasterReleaseTool = {
     }
   }
 };
+var getMasterReleaseVersionsTool = {
+  name: "get_master_release_versions",
+  description: "Retrieves a list of all Releases that are versions of this master",
+  parameters: MasterReleaseVersionsParamSchema,
+  execute: async (args) => {
+    try {
+      const masterReleaseService = new MasterReleaseService();
+      const masterReleaseVersions = await masterReleaseService.getVersions(args);
+      return JSON.stringify(masterReleaseVersions);
+    } catch (error) {
+      throw formatDiscogsError(error);
+    }
+  }
+};
 var getReleaseTool = {
   name: "get_release",
   description: "Get a release",
@@ -987,73 +1066,681 @@ var getReleaseCommunityRatingTool = {
   parameters: ReleaseIdParamSchema,
   execute: async (args) => {
     try {
-      const releaseService = new ReleaseService();
-      const releaseRating = await releaseService.getCommunityRating(args);
-      return JSON.stringify(releaseRating);
+      const releaseService = new ReleaseService();
+      const releaseRating = await releaseService.getCommunityRating(args);
+      return JSON.stringify(releaseRating);
+    } catch (error) {
+      throw formatDiscogsError(error);
+    }
+  }
+};
+var getReleaseRatingTool = {
+  name: "get_release_rating_by_user",
+  description: `Retrieves the release's rating for a given user`,
+  parameters: ReleaseRatingParamsSchema,
+  execute: async (args) => {
+    try {
+      const releaseService = new ReleaseService();
+      const releaseRating = await releaseService.getRatingByUser(args);
+      return JSON.stringify(releaseRating);
+    } catch (error) {
+      throw formatDiscogsError(error);
+    }
+  }
+};
+var searchTool = {
+  name: "search",
+  description: "Issue a search query to the Discogs database",
+  parameters: SearchParamsSchema,
+  execute: async (args) => {
+    try {
+      const databaseService = new DatabaseService();
+      const searchResults = await databaseService.search(args);
+      return JSON.stringify(searchResults);
+    } catch (error) {
+      throw formatDiscogsError(error);
+    }
+  }
+};
+function registerDatabaseTools(server) {
+  server.addTool(getReleaseTool);
+  server.addTool(getReleaseRatingTool);
+  server.addTool(editReleaseRatingTool);
+  server.addTool(deleteReleaseRatingTool);
+  server.addTool(getReleaseCommunityRatingTool);
+  server.addTool(getMasterReleaseTool);
+  server.addTool(getMasterReleaseVersionsTool);
+  server.addTool(getArtistTool);
+  server.addTool(getArtistReleasesTool);
+  server.addTool(getLabelTool);
+  server.addTool(getLabelReleasesTool);
+  server.addTool(searchTool);
+}
+var InventoryIdParamSchema = z.object({
+  id: z.number()
+});
+var InventoryExportItemSchema = z.object({
+  status: z.string(),
+  created_ts: z.string().nullable(),
+  url: urlOrEmptySchema(),
+  finished_ts: z.string().nullable(),
+  download_url: urlOrEmptySchema(),
+  filename: z.string(),
+  id: z.number()
+});
+var InventoryExportsResponseSchema = PaginatedResponseSchema(
+  InventoryExportItemSchema,
+  "items"
+);
+
+// src/services/inventory.ts
+var InventoryService = class extends DiscogsService {
+  constructor() {
+    super("/inventory");
+  }
+  /**
+   * Download an inventory export as a CSV
+   *
+   * @param {InventoryIdParam} params - The parameters for the request
+   * @returns {string} The inventory export as a CSV
+   * @throws {DiscogsAuthenticationError} If the request is not authenticated
+   * @throws {DiscogsResourceNotFoundError} If the inventory export does not exist
+   * @throws {Error} If there's an unexpected error
+   */
+  async downloadExport({ id }) {
+    try {
+      const response = await this.request(`/export/${id}/download`);
+      return response;
+    } catch (error) {
+      if (isDiscogsError(error)) {
+        throw error;
+      }
+      throw new Error(`Failed to download inventory export: ${String(error)}`);
+    }
+  }
+  /**
+   * Request an export of your inventory as a CSV
+   *
+   * @returns {void}
+   * @throws {DiscogsAuthenticationError} If the request is not authenticated
+   * @throws {Error} If there's an unexpected error
+   */
+  async export() {
+    try {
+      await this.request("/export", {
+        method: "POST"
+      });
+    } catch (error) {
+      if (isDiscogsError(error)) {
+        throw error;
+      }
+      throw new Error(`Failed to export inventory: ${String(error)}`);
+    }
+  }
+  /**
+   * Get details about an inventory export
+   *
+   * @param {InventoryIdParam} params - The parameters for the request
+   * @returns {InventoryExportItem} The inventory export item
+   * @throws {DiscogsAuthenticationError} If the request is not authenticated
+   * @throws {DiscogsResourceNotFoundError} If the inventory export does not exist
+   * @throws {Error} If there's an unexpected error
+   */
+  async getExport({ id }) {
+    try {
+      const response = await this.request(`/export/${id}`);
+      const validatedResponse = InventoryExportItemSchema.parse(response);
+      return validatedResponse;
+    } catch (error) {
+      if (isDiscogsError(error)) {
+        throw error;
+      }
+      throw new Error(`Failed to get inventory export: ${String(error)}`);
+    }
+  }
+  /**
+   * Get a list of all recent exports of your inventory
+   *
+   * @returns {InventoryExportsResponse} The inventory exports
+   * @throws {DiscogsAuthenticationError} If the request is not authenticated
+   * @throws {Error} If there's an unexpected error
+   */
+  async getExports() {
+    try {
+      const response = await this.request("/export");
+      const validatedResponse = InventoryExportsResponseSchema.parse(response);
+      return validatedResponse;
+    } catch (error) {
+      if (isDiscogsError(error)) {
+        throw error;
+      }
+      throw new Error(`Failed to get inventory exports: ${String(error)}`);
+    }
+  }
+};
+
+// src/tools/inventoryExport.ts
+var downloadInventoryExportTool = {
+  name: "download_inventory_export",
+  description: "Download an inventory export as a CSV",
+  parameters: InventoryIdParamSchema,
+  execute: async (args) => {
+    try {
+      const inventoryService = new InventoryService();
+      const csv = await inventoryService.downloadExport(args);
+      return csv;
+    } catch (error) {
+      throw formatDiscogsError(error);
+    }
+  }
+};
+var getInventoryExportTool = {
+  name: "get_inventory_export",
+  description: "Get details about an inventory export",
+  parameters: InventoryIdParamSchema,
+  execute: async (args) => {
+    try {
+      const inventoryService = new InventoryService();
+      const exportItem = await inventoryService.getExport(args);
+      return JSON.stringify(exportItem);
+    } catch (error) {
+      throw formatDiscogsError(error);
+    }
+  }
+};
+var getInventoryExportsTool = {
+  name: "get_inventory_exports",
+  description: "Get a list of all recent exports of your inventory",
+  parameters: z.object({}),
+  execute: async () => {
+    try {
+      const inventoryService = new InventoryService();
+      const exports = await inventoryService.getExports();
+      return JSON.stringify(exports);
+    } catch (error) {
+      throw formatDiscogsError(error);
+    }
+  }
+};
+var inventoryExportTool = {
+  name: "inventory_export",
+  description: "Request an export of your inventory as a CSV",
+  parameters: z.object({}),
+  execute: async () => {
+    try {
+      const inventoryService = new InventoryService();
+      await inventoryService.export();
+      return "Inventory export requested";
+    } catch (error) {
+      throw formatDiscogsError(error);
+    }
+  }
+};
+function registerInventoryExportTool(server) {
+  server.addTool(inventoryExportTool);
+  server.addTool(getInventoryExportsTool);
+  server.addTool(getInventoryExportTool);
+  server.addTool(downloadInventoryExportTool);
+}
+var ConditionSchema = z.enum([
+  "Mint (M)",
+  "Near Mint (NM or M-)",
+  "Very Good Plus (VG+)",
+  "Very Good (VG)",
+  "Good Plus (G+)",
+  "Good (G)",
+  "Fair (F)",
+  "Poor (P)"
+]);
+var SleeveConditionSchema = z.enum([
+  ...ConditionSchema.options,
+  "Generic",
+  "Not Graded",
+  "No Cover"
+]);
+var OrderStatusSchema = z.enum([
+  "New Order",
+  "Buyer Contacted",
+  "Invoice Sent",
+  "Payment Pending",
+  "Payment Received",
+  "Shipped",
+  "Refund Sent",
+  "Cancelled (Non-Paying Buyer)",
+  "Cancelled (Item Unavailable)",
+  `Cancelled (Per Buyer's Request)`
+]);
+var ListingReleaseSchema = z.object({
+  catalog_number: z.string().optional(),
+  resource_url: urlOrEmptySchema(),
+  year: z.number(),
+  id: z.number().int(),
+  description: z.string(),
+  images: z.array(ImageSchema).optional(),
+  artist: z.string(),
+  title: z.string(),
+  format: z.string(),
+  thumbnail: urlOrEmptySchema(),
+  stats: z.object({
+    community: z.object({
+      in_wantlist: z.number().int(),
+      in_collection: z.number().int()
+    }),
+    user: z.object({
+      in_wantlist: z.number().int(),
+      in_collection: z.number().int()
+    }).optional()
+  })
+});
+var PriceSchema = z.object({
+  currency: CurrencyCodeSchema.optional(),
+  value: z.number().optional()
+});
+var OriginalPriceSchema = z.object({
+  curr_abbr: CurrencyCodeSchema.optional(),
+  curr_id: z.number().optional(),
+  formatted: z.string().optional(),
+  value: z.number().optional()
+});
+var OrderMessageSchema = z.object({
+  timestamp: z.string().optional(),
+  message: z.string(),
+  type: z.string().optional(),
+  order: z.object({
+    id: z.number(),
+    resource_url: urlOrEmptySchema()
+  }),
+  subject: z.string().optional(),
+  refund: z.object({
+    amount: z.number(),
+    order: z.object({
+      id: z.number(),
+      resource_url: urlOrEmptySchema()
+    })
+  }).optional(),
+  from: z.object({
+    id: z.number().optional(),
+    resource_url: urlOrEmptySchema(),
+    username: z.string(),
+    avatar_url: urlOrEmptySchema().optional()
+  }).optional(),
+  status_id: z.number().optional(),
+  actor: z.object({
+    username: z.string(),
+    resource_url: urlOrEmptySchema()
+  }).optional(),
+  original: z.number().optional(),
+  new: z.number().optional()
+});
+var SaleStatusSchema = z.enum(["For Sale", "Expired", "Draft", "Pending"]);
+var ListingSchema = z.object({
+  id: z.number(),
+  resource_url: z.string().url(),
+  uri: z.string().url(),
+  status: SaleStatusSchema,
+  condition: z.string(),
+  sleeve_condition: z.string(),
+  comments: z.string().optional(),
+  ships_from: z.string(),
+  posted: z.string(),
+  allow_offers: z.boolean(),
+  offer_submitted: z.boolean().optional(),
+  audio: z.boolean(),
+  price: PriceSchema,
+  original_price: OriginalPriceSchema,
+  shipping_price: PriceSchema.optional(),
+  original_shipping_price: OriginalPriceSchema.optional(),
+  seller: z.object({
+    id: z.number(),
+    username: z.string(),
+    resource_url: urlOrEmptySchema().optional(),
+    avatar_url: urlOrEmptySchema().optional(),
+    stats: z.object({
+      rating: z.string(),
+      stars: z.number(),
+      total: z.number()
+    }),
+    min_order_total: z.number(),
+    html_url: urlOrEmptySchema(),
+    uid: z.number(),
+    url: urlOrEmptySchema(),
+    payment: z.string(),
+    shipping: z.string()
+  }),
+  release: ListingReleaseSchema
+});
+var ListingIdParamSchema = z.object({
+  listing_id: z.number().int()
+});
+var ListingGetParamsSchema = ListingIdParamSchema.extend({
+  curr_abbr: CurrencyCodeSchema.optional()
+});
+var ListingNewParamsSchema = z.object({
+  release_id: z.number().int(),
+  condition: ConditionSchema,
+  sleeve_condition: SleeveConditionSchema.optional(),
+  price: z.number(),
+  comments: z.string().optional(),
+  allow_offers: z.boolean().optional(),
+  status: SaleStatusSchema,
+  external_id: z.string().optional(),
+  location: z.string().optional(),
+  weight: z.number().optional(),
+  format_quantity: z.number().optional()
+});
+var ListingNewResponseSchema = z.object({
+  listing_id: z.number().int(),
+  resource_url: z.string().url()
+});
+var ListingUpdateParamsSchema = ListingIdParamSchema.merge(ListingNewParamsSchema);
+var OrderIdParamSchema = z.object({
+  order_id: z.number()
+});
+var OrderCreateMessageParamsSchema = OrderIdParamSchema.extend({
+  message: z.string().optional(),
+  status: OrderStatusSchema.optional()
+});
+var OrderEditParamsSchema = OrderIdParamSchema.extend({
+  status: OrderStatusSchema.optional(),
+  shipping: z.number().optional()
+});
+var OrderMessagesParamsSchema = QueryParamsSchema().merge(OrderIdParamSchema);
+var OrderMessagesResponseSchema = PaginatedResponseSchema(OrderMessageSchema, "messages");
+var OrdersParamsSchema = z.object({
+  status: OrderStatusSchema.optional(),
+  created_after: z.string().optional(),
+  created_before: z.string().optional(),
+  archived: z.boolean().optional()
+}).merge(QueryParamsSchema(["id", "buyer", "created", "status", "last_activity"]));
+var OrderResponseSchema = z.object({
+  id: z.number(),
+  resource_url: urlOrEmptySchema(),
+  messages_url: urlOrEmptySchema(),
+  uri: urlOrEmptySchema(),
+  status: OrderStatusSchema,
+  next_status: z.array(OrderStatusSchema),
+  fee: PriceSchema,
+  created: z.string(),
+  items: z.array(
+    z.object({
+      release: z.object({
+        id: z.number(),
+        description: z.string().optional()
+      }),
+      price: PriceSchema,
+      media_condition: ConditionSchema,
+      sleeve_condition: SleeveConditionSchema.optional(),
+      id: z.number()
+    })
+  ),
+  shipping: z.object({
+    currency: CurrencyCodeSchema,
+    method: z.string(),
+    value: z.number()
+  }),
+  shipping_address: z.string(),
+  address_instructions: z.string().optional(),
+  archived: z.boolean().optional(),
+  seller: z.object({
+    id: z.number(),
+    username: z.string(),
+    resource_url: urlOrEmptySchema().optional()
+  }),
+  last_activity: z.string().optional(),
+  buyer: z.object({
+    id: z.number(),
+    username: z.string(),
+    resource_url: urlOrEmptySchema().optional()
+  }),
+  total: PriceSchema
+});
+var OrdersResponseSchema = PaginatedResponseSchema(OrderResponseSchema, "orders");
+var ReleaseStatsResponseSchema = z.object({
+  lowest_price: PriceSchema.nullable().optional(),
+  num_for_sale: z.number().nullable().optional(),
+  blocked_from_sale: z.boolean()
+});
+
+// src/services/marketplace.ts
+var MarketplaceService = class extends DiscogsService {
+  constructor() {
+    super("/marketplace");
+  }
+  /**
+   * Create a new marketplace listing
+   *
+   * @param params - Parameters containing the listing data
+   * @returns {ListingNewResponse} The listing information
+   * @throws {DiscogsAuthenticationError} If the user is not authenticated
+   * @throws {DiscogsPermissionError} If the user does not have permission to create a listing
+   * @throws {Error} If there's an unexpected error
+   */
+  async createListing(params) {
+    try {
+      const response = await this.request(`/listings`, {
+        method: "POST",
+        body: params
+      });
+      const validatedResponse = ListingNewResponseSchema.parse(response);
+      return validatedResponse;
+    } catch (error) {
+      if (isDiscogsError(error)) {
+        throw error;
+      }
+      throw new Error(`Failed to create listing: ${String(error)}`);
+    }
+  }
+  /**
+   * Adds a new message to the order's message log
+   *
+   * @param params - Parameters containing the order ID and the message data
+   * @returns {OrderMessageResponse} The order message information
+   * @throws {DiscogsAuthenticationError} If the user is not authenticated
+   * @throws {DiscogsPermissionError} If the user does not have permission to create a message
+   * @throws {DiscogsResourceNotFoundError} If the order cannot be found
+   * @throws {Error} If there's an unexpected error
+   */
+  async createOrderMessage({
+    order_id,
+    ...body
+  }) {
+    try {
+      const response = await this.request(`/orders/${order_id}/messages`, {
+        method: "POST",
+        body
+      });
+      const validatedResponse = OrderMessageSchema.parse(response);
+      return validatedResponse;
+    } catch (error) {
+      if (isDiscogsError(error)) {
+        throw error;
+      }
+      throw new Error(`Failed to create order message: ${String(error)}`);
+    }
+  }
+  /**
+   * Delete a listing from the marketplace
+   *
+   * @param params - Parameters containing the listing ID
+   * @throws {DiscogsAuthenticationError} If the user is not authenticated
+   * @throws {DiscogsPermissionError} If the user does not have permission to delete a listing
+   * @throws {DiscogsResourceNotFoundError} If the listing cannot be found
+   * @throws {Error} If there's an unexpected error
+   */
+  async deleteListing({ listing_id }) {
+    try {
+      await this.request(`/listings/${listing_id}`, {
+        method: "DELETE"
+      });
+    } catch (error) {
+      if (isDiscogsError(error)) {
+        throw error;
+      }
+      throw new Error(`Failed to delete listing: ${String(error)}`);
+    }
+  }
+  /**
+   * The Listing resource allows you to view Marketplace listings
+   *
+   * @param params - Parameters containing the listing ID and optional currency code
+   * @returns {Listing} The listing information
+   * @throws {DiscogsResourceNotFoundError} If the listing cannot be found
+   * @throws {Error} If there's an unexpected error
+   */
+  async getListing({ listing_id, ...options }) {
+    try {
+      const response = await this.request(`/listings/${listing_id}`, {
+        params: options
+      });
+      const validatedResponse = ListingSchema.parse(response);
+      return validatedResponse;
+    } catch (error) {
+      if (isDiscogsError(error)) {
+        throw error;
+      }
+      throw new Error(`Failed to get listing: ${String(error)}`);
+    }
+  }
+  /**
+   * Get a marketplace order
+   *
+   * @param params - Parameters containing the order ID
+   * @throws {DiscogsAuthenticationError} If the user is not authenticated
+   * @throws {DiscogsPermissionError} If the user does not have permission to view the order
+   * @throws {DiscogsResourceNotFoundError} If the order cannot be found
+   * @throws {Error} If there's an unexpected error
+   * @returns {OrderResponse} The order information
+   */
+  async getOrder({ order_id }) {
+    try {
+      const response = await this.request(`/orders/${order_id}`);
+      const validatedResponse = OrderResponseSchema.parse(response);
+      return validatedResponse;
+    } catch (error) {
+      if (isDiscogsError(error)) {
+        throw error;
+      }
+      throw new Error(`Failed to get order: ${String(error)}`);
+    }
+  }
+  /**
+   * Get a list of an order's messages
+   *
+   * @param params - OrderMessagesParams
+   * @throws {DiscogsAuthenticationError} If the user is not authenticated
+   * @throws {DiscogsPermissionError} If the user does not have permission to view the order messages
+   * @throws {DiscogsResourceNotFoundError} If the order cannot be found
+   * @throws {Error} If there's an unexpected error
+   * @returns {OrderMessagesResponse} The order messages
+   */
+  async getOrderMessages({
+    order_id,
+    ...options
+  }) {
+    try {
+      const response = await this.request(`/orders/${order_id}/messages`, {
+        params: options
+      });
+      const validatedResponse = OrderMessagesResponseSchema.parse(response);
+      return validatedResponse;
+    } catch (error) {
+      if (isDiscogsError(error)) {
+        throw error;
+      }
+      throw new Error(`Failed to get order messages: ${String(error)}`);
+    }
+  }
+  /**
+   * Get a list of marketplace orders
+   *
+   * @param params - OrdersParams
+   * @throws {DiscogsAuthenticationError} If the user is not authenticated
+   * @throws {DiscogsPermissionError} If the user does not have permission to view the orders
+   * @throws {Error} If there's an unexpected error
+   * @returns {OrdersResponse} The order information
+   */
+  async getOrders(params) {
+    try {
+      const response = await this.request(`/orders`, {
+        params
+      });
+      const validatedResponse = OrdersResponseSchema.parse(response);
+      return validatedResponse;
     } catch (error) {
-      throw formatDiscogsError(error);
+      if (isDiscogsError(error)) {
+        throw error;
+      }
+      throw new Error(`Failed to get orders: ${String(error)}`);
     }
   }
-};
-var getReleaseRatingTool = {
-  name: "get_release_rating_by_user",
-  description: `Retrieves the release's rating for a given user`,
-  parameters: ReleaseRatingParamsSchema,
-  execute: async (args) => {
+  /**
+   * Retrieve marketplace statistics for the provided Release ID
+   *
+   * @param params - Parameters containing the release ID and optional currency code
+   * @throws {DiscogsResourceNotFoundError} If the release cannot be found
+   * @throws {Error} If there's an unexpected error
+   * @returns {ReleaseStatsResponse} The release stats
+   */
+  async getReleaseStats({ release_id, ...options }) {
     try {
-      const releaseService = new ReleaseService();
-      const releaseRating = await releaseService.getRatingByUser(args);
-      return JSON.stringify(releaseRating);
+      const response = await this.request(`/stats/${release_id}`, {
+        params: options
+      });
+      const validatedResponse = ReleaseStatsResponseSchema.parse(response);
+      return validatedResponse;
     } catch (error) {
-      throw formatDiscogsError(error);
+      if (isDiscogsError(error)) {
+        throw error;
+      }
+      throw new Error(`Failed to get release stats: ${String(error)}`);
     }
   }
-};
-var searchTool = {
-  name: "search",
-  description: "Issue a search query to the Discogs database",
-  parameters: SearchParamsSchema,
-  execute: async (args) => {
+  /**
+   * Edit a marketplace order
+   *
+   * @param params - Parameters containing the order ID and the order data
+   * @throws {DiscogsAuthenticationError} If the user is not authenticated
+   * @throws {DiscogsPermissionError} If the user does not have permission to edit the order
+   * @throws {DiscogsResourceNotFoundError} If the order cannot be found
+   * @throws {Error} If there's an unexpected error
+   */
+  async editOrder({ order_id, ...body }) {
     try {
-      const databaseService = new DatabaseService();
-      const searchResults = await databaseService.search(args);
-      return JSON.stringify(searchResults);
+      const response = await this.request(`/orders/${order_id}`, {
+        method: "POST",
+        body
+      });
+      const validatedResponse = OrderResponseSchema.parse(response);
+      return validatedResponse;
     } catch (error) {
-      throw formatDiscogsError(error);
+      if (isDiscogsError(error)) {
+        throw error;
+      }
+      throw new Error(`Failed to edit order: ${String(error)}`);
     }
   }
-};
-function registerDatabaseTools(server) {
-  server.addTool(getReleaseTool);
-  server.addTool(getReleaseRatingTool);
-  server.addTool(editReleaseRatingTool);
-  server.addTool(deleteReleaseRatingTool);
-  server.addTool(getReleaseCommunityRatingTool);
-  server.addTool(getMasterReleaseTool);
-  server.addTool(getArtistTool);
-  server.addTool(getArtistReleasesTool);
-  server.addTool(getLabelTool);
-  server.addTool(getLabelReleasesTool);
-  server.addTool(searchTool);
-}
-var MediaParamsSchema = z.object({
-  url: z.string().url()
-});
-var fetchImageTool = {
-  name: "fetch_image",
-  description: "Fetch an image by URL",
-  parameters: MediaParamsSchema,
-  execute: async ({ url }) => {
+  /**
+   * Update a marketplace listing
+   *
+   * @param params - Parameters containing the listing ID and the listing data
+   * @throws {DiscogsAuthenticationError} If the user is not authenticated
+   * @throws {DiscogsResourceNotFoundError} If the listing cannot be found
+   * @throws {Error} If there's an unexpected error
+   */
+  async updateListing({ listing_id, ...body }) {
     try {
-      return imageContent({ url });
+      await this.request(`/listings/${listing_id}`, {
+        method: "POST",
+        body
+      });
     } catch (error) {
-      throw formatDiscogsError(error);
+      if (isDiscogsError(error)) {
+        throw error;
+      }
+      throw new Error(`Failed to update listing: ${String(error)}`);
     }
   }
 };
-function registerMediaTools(server) {
-  server.addTool(fetchImageTool);
-}
 var FolderIdParamSchema = (min) => z.object({
   folder_id: z.number().int().min(min ?? 0)
 });
@@ -1140,6 +1827,24 @@ var UserCollectionValueSchema = z.object({
   median: z.string(),
   minimum: z.string()
 });
+
+// src/types/user/inventory.ts
+var UserInventoryGetParamsSchema = UsernameInputSchema.extend({
+  status: SaleStatusSchema.optional()
+}).merge(
+  QueryParamsSchema([
+    "listed",
+    "price",
+    "item",
+    "artist",
+    "label",
+    "catno",
+    "audio",
+    "status",
+    "location"
+  ])
+);
+var UserInventoryResponseSchema = PaginatedResponseSchema(ListingSchema, "listings");
 var UserListItemSchema = z.object({
   id: z.number(),
   date_added: z.string(),
@@ -1217,6 +1922,218 @@ var UserWantlistItemParamsSchema = UsernameInputSchema.merge(
   })
 );
 
+// src/services/user/inventory.ts
+var UserInventoryService = class extends BaseUserService {
+  /**
+   * Returns the list of listings in a user's inventory
+   * @param params - Parameters for the request including username and optional pagination/sorting
+   * @returns {UserInventoryResponse} A paginated response containing the user's inventory
+   * @throws {DiscogsResourceNotFoundError} If the username cannot be found
+   * @throws {Error} If there's an unexpected error
+   */
+  async get({ username, ...options }) {
+    try {
+      const response = await this.request(`/${username}/inventory`, {
+        params: options
+      });
+      const validatedResponse = UserInventoryResponseSchema.parse(response);
+      return validatedResponse;
+    } catch (error) {
+      if (isDiscogsError(error)) {
+        throw error;
+      }
+      throw new Error(`Failed to get inventory: ${String(error)}`);
+    }
+  }
+};
+
+// src/tools/marketplace.ts
+var createMarketplaceListingTool = {
+  name: "create_marketplace_listing",
+  description: "Create a new marketplace listing",
+  parameters: ListingNewParamsSchema,
+  execute: async (args) => {
+    try {
+      const marketplaceService = new MarketplaceService();
+      const listing = await marketplaceService.createListing(args);
+      return JSON.stringify(listing);
+    } catch (error) {
+      throw formatDiscogsError(error);
+    }
+  }
+};
+var createMarketplaceOrderMessageTool = {
+  name: "create_marketplace_order_message",
+  description: `Adds a new message to the order's message log`,
+  parameters: OrderCreateMessageParamsSchema,
+  execute: async (args) => {
+    try {
+      const marketplaceService = new MarketplaceService();
+      const message = await marketplaceService.createOrderMessage(args);
+      return JSON.stringify(message);
+    } catch (error) {
+      throw formatDiscogsError(error);
+    }
+  }
+};
+var deleteMarketplaceListingTool = {
+  name: "delete_marketplace_listing",
+  description: "Delete a marketplace listing",
+  parameters: ListingIdParamSchema,
+  execute: async (args) => {
+    try {
+      const marketplaceService = new MarketplaceService();
+      await marketplaceService.deleteListing(args);
+      return "Listing deleted successfully";
+    } catch (error) {
+      throw formatDiscogsError(error);
+    }
+  }
+};
+var getMarketplaceListingTool = {
+  name: "get_marketplace_listing",
+  description: "Get a listing from the marketplace",
+  parameters: ListingGetParamsSchema,
+  execute: async (args) => {
+    try {
+      const marketplaceService = new MarketplaceService();
+      const listing = await marketplaceService.getListing(args);
+      return JSON.stringify(listing);
+    } catch (error) {
+      throw formatDiscogsError(error);
+    }
+  }
+};
+var getMarketplaceOrderTool = {
+  name: "get_marketplace_order",
+  description: "Get a marketplace order",
+  parameters: OrderIdParamSchema,
+  execute: async (args) => {
+    try {
+      const marketplaceService = new MarketplaceService();
+      const order = await marketplaceService.getOrder(args);
+      return JSON.stringify(order);
+    } catch (error) {
+      throw formatDiscogsError(error);
+    }
+  }
+};
+var getMarketplaceOrdersTool = {
+  name: "get_marketplace_orders",
+  description: "Get a list of marketplace orders",
+  parameters: OrdersParamsSchema,
+  execute: async (args) => {
+    try {
+      const marketplaceService = new MarketplaceService();
+      const orders = await marketplaceService.getOrders(args);
+      return JSON.stringify(orders);
+    } catch (error) {
+      throw formatDiscogsError(error);
+    }
+  }
+};
+var getMarketplaceOrderMessagesTool = {
+  name: "get_marketplace_order_messages",
+  description: `Get a list of an order's messages`,
+  parameters: OrderMessagesParamsSchema,
+  execute: async (args) => {
+    try {
+      const marketplaceService = new MarketplaceService();
+      const messages = await marketplaceService.getOrderMessages(args);
+      return JSON.stringify(messages);
+    } catch (error) {
+      throw formatDiscogsError(error);
+    }
+  }
+};
+var getMarketplaceReleaseStatsTool = {
+  name: "get_marketplace_release_stats",
+  description: "Retrieve marketplace statistics for the provided Release ID",
+  parameters: ReleaseParamsSchema,
+  execute: async (args) => {
+    try {
+      const marketplaceService = new MarketplaceService();
+      const stats = await marketplaceService.getReleaseStats(args);
+      return JSON.stringify(stats);
+    } catch (error) {
+      throw formatDiscogsError(error);
+    }
+  }
+};
+var getUserInventoryTool = {
+  name: "get_user_inventory",
+  description: `Returns the list of listings in a user's inventory`,
+  parameters: UserInventoryGetParamsSchema,
+  execute: async (args) => {
+    try {
+      const userInventoryService = new UserInventoryService();
+      const inventory = await userInventoryService.get(args);
+      return JSON.stringify(inventory);
+    } catch (error) {
+      throw formatDiscogsError(error);
+    }
+  }
+};
+var editMarketplaceOrderTool = {
+  name: "edit_marketplace_order",
+  description: "Edit a marketplace order",
+  parameters: OrderEditParamsSchema,
+  execute: async (args) => {
+    try {
+      const marketplaceService = new MarketplaceService();
+      const order = await marketplaceService.editOrder(args);
+      return JSON.stringify(order);
+    } catch (error) {
+      throw formatDiscogsError(error);
+    }
+  }
+};
+var updateMarketplaceListingTool = {
+  name: "update_marketplace_listing",
+  description: "Update a marketplace listing",
+  parameters: ListingUpdateParamsSchema,
+  execute: async (args) => {
+    try {
+      const marketplaceService = new MarketplaceService();
+      await marketplaceService.updateListing(args);
+      return "Listing updated successfully";
+    } catch (error) {
+      throw formatDiscogsError(error);
+    }
+  }
+};
+function registerMarketplaceTools(server) {
+  server.addTool(getUserInventoryTool);
+  server.addTool(getMarketplaceListingTool);
+  server.addTool(createMarketplaceListingTool);
+  server.addTool(updateMarketplaceListingTool);
+  server.addTool(deleteMarketplaceListingTool);
+  server.addTool(getMarketplaceOrderTool);
+  server.addTool(editMarketplaceOrderTool);
+  server.addTool(getMarketplaceOrdersTool);
+  server.addTool(getMarketplaceOrderMessagesTool);
+  server.addTool(createMarketplaceOrderMessageTool);
+  server.addTool(getMarketplaceReleaseStatsTool);
+}
+var MediaParamsSchema = z.object({
+  url: z.string().url()
+});
+var fetchImageTool = {
+  name: "fetch_image",
+  description: "Fetch an image by URL",
+  parameters: MediaParamsSchema,
+  execute: async ({ url }) => {
+    try {
+      return imageContent({ url });
+    } catch (error) {
+      throw formatDiscogsError(error);
+    }
+  }
+};
+function registerMediaTools(server) {
+  server.addTool(fetchImageTool);
+}
+
 // src/services/user/collection.ts
 var UserCollectionService = class extends BaseUserService {
   /**
@@ -2010,6 +2927,76 @@ var OAuthService = class extends DiscogsService {
     }
   }
 };
+var SubmissionSchema = z.object({
+  artists: z.array(ArtistSchema).optional(),
+  labels: z.array(LabelSchema).optional(),
+  releases: z.array(ReleaseSchema).optional()
+});
+var ContributionsParamsSchema = UsernameInputSchema.merge(
+  QueryParamsSchema([
+    "label",
+    "artist",
+    "title",
+    "catno",
+    "format",
+    "rating",
+    "year",
+    "added"
+  ])
+);
+var ContributionsResponseSchema = PaginatedResponseSchema(ReleaseSchema, "contributions");
+var SubmissionsResponseSchema = PaginatedResponseWithObjectSchema(
+  SubmissionSchema,
+  "submissions"
+);
+
+// src/services/user/contribution.ts
+var UserContributionsService = class extends BaseUserService {
+  /**
+   * Retrieve a user's contributions by username
+   *
+   * @param username The username of the user to get contributions for
+   * @throws {DiscogsResourceNotFoundError} If the username is not found
+   * @throws {DiscogsError} If there's an unexpected error
+   * @returns {ContributionsResponse} The user's contributions
+   */
+  async get({ username, ...options }) {
+    try {
+      const response = await this.request(`/${username}/contributions`, {
+        params: options
+      });
+      const validatedResponse = ContributionsResponseSchema.parse(response);
+      return validatedResponse;
+    } catch (error) {
+      if (isDiscogsError(error)) {
+        throw error;
+      }
+      throw new Error(`Failed to get user contributions: ${String(error)}`);
+    }
+  }
+};
+var UserSubmissionsService = class extends BaseUserService {
+  /**
+   * Retrieve a user's submissions by username
+   *
+   * @param username The username of the user to get submissions for
+   * @throws {DiscogsResourceNotFoundError} If the username is not found
+   * @throws {DiscogsError} If there's an unexpected error
+   * @returns {SubmissionResponse} The user's submissions
+   */
+  async get({ username }) {
+    try {
+      const response = await this.request(`/${username}/submissions`);
+      const validatedResponse = SubmissionsResponseSchema.parse(response);
+      return validatedResponse;
+    } catch (error) {
+      if (isDiscogsError(error)) {
+        throw error;
+      }
+      throw new Error(`Failed to get user submissions: ${String(error)}`);
+    }
+  }
+};
 
 // src/tools/userIdentity.ts
 var getUserIdentityTool = {
@@ -2040,6 +3027,34 @@ var getUserProfileTool = {
     }
   }
 };
+var getUserSubmissionsTool = {
+  name: "get_user_submissions",
+  description: `Retrieve a user's submissions by username`,
+  parameters: UsernameInputSchema,
+  execute: async (args) => {
+    try {
+      const userSubmissionsService = new UserSubmissionsService();
+      const submissions = await userSubmissionsService.get(args);
+      return JSON.stringify(submissions);
+    } catch (error) {
+      throw formatDiscogsError(error);
+    }
+  }
+};
+var getUserContributionsTool = {
+  name: "get_user_contributions",
+  description: `Retrieve a user's contributions by username`,
+  parameters: ContributionsParamsSchema,
+  execute: async (args) => {
+    try {
+      const userContributionsService = new UserContributionsService();
+      const contributions = await userContributionsService.get(args);
+      return JSON.stringify(contributions);
+    } catch (error) {
+      throw formatDiscogsError(error);
+    }
+  }
+};
 var editUserProfileTool = {
   name: "edit_user_profile",
   description: `Edit a user's profile data`,
@@ -2058,6 +3073,8 @@ function registerUserIdentityTools(server) {
   server.addTool(getUserIdentityTool);
   server.addTool(getUserProfileTool);
   server.addTool(editUserProfileTool);
+  server.addTool(getUserSubmissionsTool);
+  server.addTool(getUserContributionsTool);
 }
 var ListItemSchema = z.object({
   id: z.number(),
@@ -2229,6 +3246,8 @@ function registerUserWantlistTools(server) {
 // src/tools/index.ts
 function registerTools(server) {
   registerDatabaseTools(server);
+  registerMarketplaceTools(server);
+  registerInventoryExportTool(server);
   registerUserIdentityTools(server);
   registerUserCollectionTools(server);
   registerUserWantlistTools(server);