discogs-mcp-server 0.1.0

package/dist/index.js

@@ -0,0 +1,2275 @@
+#!/usr/bin/env node
+import { FastMCP, imageContent, UserError } from 'fastmcp';
+import dotenv from 'dotenv';
+import { z } from 'zod';
+
+// src/version.ts
+var VERSION = "0.1.0";
+
+// src/config.ts
+dotenv.config();
+var config = {
+  discogs: {
+    apiUrl: process.env.DISCOGS_API_URL || "https://api.discogs.com",
+    /* Some MCP clients can't handle large amounts of data.
+     * The client may explicitly request more at their own peril. */
+    defaultPerPage: 5,
+    mediaType: process.env.DISCOGS_MEDIA_TYPE || "application/vnd.discogs.v2.discogs+json",
+    personalAccessToken: process.env.DISCOGS_PERSONAL_ACCESS_TOKEN,
+    userAgent: process.env.DISCOGS_USER_AGENT || `DiscogsMCPServer/${VERSION}`
+  },
+  server: {
+    name: process.env.SERVER_NAME || "Discogs MCP Server",
+    port: process.env.PORT ? parseInt(process.env.PORT, 10) : 3001
+  }
+};
+function validateConfig() {
+  const missingVars = [];
+  if (!process.env.DISCOGS_PERSONAL_ACCESS_TOKEN) {
+    missingVars.push("DISCOGS_PERSONAL_ACCESS_TOKEN");
+  }
+  if (missingVars.length > 0) {
+    throw new Error(`Missing required environment variables: ${missingVars.join(", ")}`);
+  }
+}
+var DiscogsError = class extends Error {
+  constructor(message, status, response) {
+    super(message);
+    this.status = status;
+    this.response = response;
+    this.name = new.target.name;
+  }
+};
+var DiscogsAuthenticationError = class extends DiscogsError {
+  constructor(message = "Authentication failed") {
+    super(message, 401, { message });
+    this.name = new.target.name;
+  }
+};
+var DiscogsMethodNotAllowedError = class extends DiscogsError {
+  constructor(message = "Method not allowed") {
+    super(message, 405, { message });
+    this.name = new.target.name;
+  }
+};
+var DiscogsPermissionError = class extends DiscogsError {
+  constructor(message = "Insufficient permissions") {
+    super(message, 403, { message });
+    this.name = new.target.name;
+  }
+};
+var DiscogsRateLimitError = class extends DiscogsError {
+  constructor(message = "Rate limit exceeded", resetAt) {
+    super(message, 429, { message, reset_at: resetAt.toISOString() });
+    this.resetAt = resetAt;
+    this.name = new.target.name;
+  }
+};
+var DiscogsResourceNotFoundError = class extends DiscogsError {
+  constructor(message = "Resource not found") {
+    super(message, 404, { message });
+    this.name = new.target.name;
+  }
+};
+var DiscogsValidationFailedError = class extends DiscogsError {
+  constructor(response) {
+    let message = "Validation failed";
+    if (response && typeof response === "object" && response !== null) {
+      const detail = response.detail;
+      if (Array.isArray(detail) && detail.length > 0 && detail[0].msg) {
+        message = detail[0].msg;
+      }
+    }
+    super(message, 422, { message });
+    this.name = new.target.name;
+  }
+};
+function createDiscogsError(status, response) {
+  switch (status) {
+    case 401:
+      return new DiscogsAuthenticationError(response?.message);
+    case 403:
+      return new DiscogsPermissionError(response?.message);
+    case 404:
+      return new DiscogsResourceNotFoundError(response?.message || "Resource");
+    case 405:
+      return new DiscogsMethodNotAllowedError(response?.message);
+    case 422:
+      return new DiscogsValidationFailedError(response);
+    case 429:
+      return new DiscogsRateLimitError(
+        response?.message,
+        new Date(response?.reset_at || Date.now() + 6e4)
+      );
+    default:
+      return new DiscogsError(response?.message || "Discogs API error", status, response);
+  }
+}
+function formatDiscogsError(error) {
+  let message;
+  if (error instanceof Error) {
+    message = error.message;
+  } else {
+    message = String(error);
+  }
+  return new UserError(message);
+}
+function isDiscogsError(error) {
+  return error instanceof DiscogsError;
+}
+var log = {
+  _log: (level, ...args) => {
+    const msg = `[${level} ${(/* @__PURE__ */ new Date()).toISOString()}] ${args.join(" ")}
+`;
+    process.stderr.write(msg);
+  },
+  info: (...args) => {
+    log._log("INFO", ...args);
+  },
+  debug: (...args) => {
+    log._log("DEBUG", ...args);
+  },
+  warn: (...args) => {
+    log._log("WARN", ...args);
+  },
+  error: (...args) => {
+    log._log("ERROR", ...args);
+  }
+};
+var urlOrEmptySchema = () => {
+  return z.string().refine((val) => val === "" || /^https?:\/\/.+/.test(val), {
+    message: "Must be a valid URL or empty string"
+  });
+};
+var CurrencyCodeSchema = z.enum([
+  "USD",
+  // US Dollar
+  "GBP",
+  // British Pound
+  "EUR",
+  // Euro
+  "CAD",
+  // Canadian Dollar
+  "AUD",
+  // Australian Dollar
+  "JPY",
+  // Japanese Yen
+  "CHF",
+  // Swiss Franc
+  "MXN",
+  // Mexican Peso
+  "BRL",
+  // Brazilian Real
+  "NZD",
+  // New Zealand Dollar
+  "SEK",
+  // Swedish Krona
+  "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()
+    })
+  }),
+  [resultsFieldName]: z.array(itemSchema)
+});
+var QueryParamsSchema = (validSortKeys = []) => z.object({
+  // Pagination
+  page: z.number().int().min(1).optional(),
+  per_page: z.number().int().min(1).max(100).optional(),
+  // Sorting
+  sort: z.enum(validSortKeys).optional(),
+  sort_order: z.enum(["asc", "desc"]).optional()
+});
+var UsernameInputSchema = z.object({
+  username: z.string().min(1, "username is required")
+});
+
+// src/types/artist.ts
+var ArtistIdParamSchema = z.object({
+  artist_id: z.number()
+});
+var ArtistBasicSchema = z.object({
+  id: z.number(),
+  anv: z.string(),
+  join: z.string(),
+  name: z.string(),
+  resource_url: urlOrEmptySchema(),
+  role: z.string(),
+  tracks: z.string()
+});
+var ArtistSchema = z.object({
+  id: z.number(),
+  aliases: z.array(
+    z.object({
+      id: z.number(),
+      name: z.string(),
+      resource_url: urlOrEmptySchema(),
+      thumbnail_url: urlOrEmptySchema().optional()
+    })
+  ).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(),
+  members: z.array(
+    z.object({
+      id: z.number(),
+      active: z.boolean().optional(),
+      name: z.string(),
+      resource_url: urlOrEmptySchema(),
+      thumbnail_url: urlOrEmptySchema().optional()
+    })
+  ).optional(),
+  name: z.string(),
+  namevariations: z.array(z.string()).optional(),
+  profile: z.string().optional(),
+  realname: z.string().optional(),
+  releases_url: urlOrEmptySchema().optional(),
+  resource_url: urlOrEmptySchema(),
+  uri: urlOrEmptySchema().optional(),
+  urls: z.array(z.string()).optional()
+});
+var ArtistReleaseSchema = z.object({
+  id: z.number(),
+  artist: z.string(),
+  catno: z.string().optional(),
+  format: z.string().optional(),
+  label: z.string().optional(),
+  main_release: z.number().optional(),
+  resource_url: urlOrEmptySchema(),
+  role: z.string().optional(),
+  status: z.string().optional(),
+  stats: z.object({
+    community: z.object({
+      in_collection: z.number(),
+      in_wantlist: z.number()
+    }),
+    user: z.object({
+      in_collection: z.number(),
+      in_wantlist: z.number()
+    })
+  }).optional(),
+  thumb: urlOrEmptySchema().optional(),
+  title: z.string(),
+  trackinfo: z.string().optional(),
+  type: z.string().optional(),
+  year: z.number().optional()
+});
+var ArtistReleasesParamsSchema = ArtistIdParamSchema.merge(
+  QueryParamsSchema(["year", "title", "format"])
+);
+var ArtistReleasesSchema = PaginatedResponseSchema(ArtistReleaseSchema, "releases");
+
+// src/services/index.ts
+var DiscogsService = class {
+  constructor(servicePath) {
+    this.servicePath = servicePath;
+    if (!config.discogs.personalAccessToken || !config.discogs.userAgent) {
+      throw new Error("Discogs API configuration is incomplete");
+    }
+    this.baseUrl = `${config.discogs.apiUrl}${servicePath}`;
+    this.headers = {
+      Accept: config.discogs.mediaType,
+      Authorization: `Discogs token=${config.discogs.personalAccessToken}`,
+      "Content-Type": "application/json",
+      "User-Agent": config.discogs.userAgent
+    };
+  }
+  baseUrl;
+  headers;
+  async request(path, options) {
+    const url = new URL(`${this.baseUrl}${path}`);
+    if (options?.params) {
+      Object.entries(options.params).forEach(([key, value]) => {
+        if (value !== void 0) {
+          url.searchParams.append(key, String(value));
+        }
+      });
+    }
+    if (!url.searchParams.has("per_page")) {
+      url.searchParams.append("per_page", String(config.discogs.defaultPerPage));
+    }
+    const response = await fetch(url.toString(), {
+      method: options?.method || "GET",
+      headers: this.headers,
+      body: options?.body ? JSON.stringify(options.body) : void 0
+    });
+    const contentType = response.headers.get("content-type");
+    const isJson = contentType && contentType.includes("application/json");
+    let responseBody;
+    try {
+      responseBody = isJson ? await response.json() : await response.text();
+    } catch {
+      responseBody = { message: "Failed to parse response" };
+    }
+    if (!response.ok) {
+      throw createDiscogsError(response.status, responseBody);
+    }
+    return responseBody;
+  }
+};
+var BaseUserService = class extends DiscogsService {
+  constructor() {
+    super("/users");
+  }
+};
+
+// src/services/artist.ts
+var ArtistService = class extends DiscogsService {
+  constructor() {
+    super("/artists");
+  }
+  /**
+   * Get an artist
+   *
+   * @param params - Parameters containing the artist ID
+   * @returns {Artist} The artist information
+   * @throws {DiscogsResourceNotFoundError} If the artist cannot be found
+   * @throws {Error} If there's an unexpected error
+   */
+  async get({ artist_id }) {
+    try {
+      const response = await this.request(`/${artist_id}`);
+      const validatedResponse = ArtistSchema.parse(response);
+      return validatedResponse;
+    } catch (error) {
+      if (isDiscogsError(error)) {
+        throw error;
+      }
+      throw new Error(`Failed to get artist: ${String(error)}`);
+    }
+  }
+  /**
+   * Get an artist's releases
+   *
+   * @param params - Parameters containing the artist ID and pagination options
+   * @returns {ArtistReleases} The artist releases
+   * @throws {DiscogsResourceNotFoundError} If the artist cannot be found
+   * @throws {Error} If there's an unexpected error
+   */
+  async getReleases({ artist_id, ...options }) {
+    try {
+      const response = await this.request(`/${artist_id}/releases`, {
+        params: options
+      });
+      const validatedResponse = ArtistReleasesSchema.parse(response);
+      return validatedResponse;
+    } catch (error) {
+      if (isDiscogsError(error)) {
+        throw error;
+      }
+      throw new Error(`Failed to get artist releases: ${String(error)}`);
+    }
+  }
+};
+var SearchParamsSchema = z.object({
+  q: z.string().optional(),
+  type: z.enum(["artist", "label", "master", "release"]).optional(),
+  title: z.string().optional(),
+  release_title: z.string().optional(),
+  credit: z.string().optional(),
+  artist: z.string().optional(),
+  anv: z.string().optional(),
+  label: z.string().optional(),
+  genre: z.string().optional(),
+  style: z.string().optional(),
+  country: z.string().optional(),
+  year: z.string().optional(),
+  format: z.string().optional(),
+  catno: z.string().optional(),
+  barcode: z.string().optional(),
+  track: z.string().optional(),
+  submitter: z.string().optional(),
+  contributor: z.string().optional()
+}).merge(QueryParamsSchema(["title", "artist", "year"]));
+var SearchResultSchema = z.object({
+  id: z.number(),
+  barcode: z.array(z.string()).optional(),
+  catno: z.string().optional(),
+  community: z.object({
+    have: z.number(),
+    want: z.number()
+  }).optional(),
+  country: z.string().optional(),
+  cover_image: urlOrEmptySchema().optional(),
+  format: z.array(z.string()).optional(),
+  format_quantity: z.number().optional(),
+  formats: z.array(
+    z.object({
+      descriptions: z.array(z.string()).optional(),
+      name: z.string(),
+      qty: z.string(),
+      text: z.string().optional()
+    })
+  ).optional(),
+  genre: z.array(z.string()).optional(),
+  label: z.array(z.string()).optional(),
+  master_id: z.number().nullable().optional(),
+  master_url: urlOrEmptySchema().nullable().optional(),
+  resource_url: urlOrEmptySchema(),
+  style: z.array(z.string()).optional(),
+  thumb: urlOrEmptySchema().optional(),
+  title: z.string(),
+  type: z.enum(["artist", "label", "master", "release"]),
+  uri: z.string(),
+  user_data: z.object({
+    in_collection: z.boolean(),
+    in_wantlist: z.boolean()
+  }).optional(),
+  year: z.string().optional()
+});
+var SearchResultsSchema = PaginatedResponseSchema(SearchResultSchema, "results");
+
+// src/services/database.ts
+var DatabaseService = class extends DiscogsService {
+  constructor() {
+    super("/database");
+  }
+  /**
+   * Issue a search query to the Discogs database
+   *
+   * @param params - Search parameters
+   * @throws {DiscogsAuthenticationError} If authentication fails
+   * @throws {Error} If the search times out or an unexpected error occurs
+   * @returns {SearchResults} Search results
+   */
+  async search(params) {
+    try {
+      const response = await this.request("/search", { params });
+      const validatedResponse = SearchResultsSchema.parse(response);
+      return validatedResponse;
+    } catch (error) {
+      if (isDiscogsError(error)) {
+        throw error;
+      }
+      throw new Error(`Failed to search database: ${String(error)}`);
+    }
+  }
+};
+var LabelIdParamSchema = z.object({
+  label_id: z.number()
+});
+var LabelBasicSchema = z.object({
+  id: z.number(),
+  catno: z.string(),
+  entity_type: z.string().optional(),
+  entity_type_name: z.string().optional(),
+  name: z.string(),
+  resource_url: urlOrEmptySchema()
+});
+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(),
+  name: z.string(),
+  parent_label: z.object({
+    id: z.number(),
+    name: z.string(),
+    resource_url: urlOrEmptySchema()
+  }).optional(),
+  profile: z.string().optional(),
+  releases_url: urlOrEmptySchema().optional(),
+  resource_url: urlOrEmptySchema(),
+  sublabels: z.array(
+    z.object({
+      id: z.number(),
+      name: z.string(),
+      resource_url: urlOrEmptySchema()
+    })
+  ).optional(),
+  uri: urlOrEmptySchema().optional(),
+  urls: z.array(z.string()).optional()
+});
+var LabelReleasesParamsSchema = LabelIdParamSchema.merge(QueryParamsSchema());
+var LabelReleasesSchema = PaginatedResponseSchema(ArtistReleaseSchema, "releases");
+
+// src/services/label.ts
+var LabelService = class extends DiscogsService {
+  constructor() {
+    super("/labels");
+  }
+  /**
+   * Get a label
+   *
+   * @param params - Parameters containing the label ID
+   * @returns {Label} The label information
+   * @throws {DiscogsResourceNotFoundError} If the label cannot be found
+   * @throws {Error} If there's an unexpected error
+   */
+  async get({ label_id }) {
+    try {
+      const response = await this.request(`/${label_id}`);
+      const validatedResponse = LabelSchema.parse(response);
+      return validatedResponse;
+    } catch (error) {
+      if (isDiscogsError(error)) {
+        throw error;
+      }
+      throw new Error(`Failed to get label: ${String(error)}`);
+    }
+  }
+  /**
+   * Returns a list of Releases associated with the label
+   *
+   * @param params - Parameters containing the label ID and pagination options
+   * @returns {LabelReleases} The label releases
+   * @throws {DiscogsResourceNotFoundError} If the label cannot be found
+   * @throws {Error} If there's an unexpected error
+   */
+  async getReleases({ label_id, ...params }) {
+    try {
+      const response = await this.request(`/${label_id}/releases`, {
+        params
+      });
+      const validatedResponse = LabelReleasesSchema.parse(response);
+      return validatedResponse;
+    } catch (error) {
+      if (isDiscogsError(error)) {
+        throw error;
+      }
+      throw new Error(`Failed to get label releases: ${String(error)}`);
+    }
+  }
+};
+var ReleaseFormatSchema = z.object({
+  descriptions: z.array(z.string()).optional(),
+  name: z.string(),
+  qty: z.string(),
+  text: z.string().optional()
+});
+var BasicInformationSchema = z.object({
+  id: z.number(),
+  artists: z.array(ArtistBasicSchema),
+  cover_image: urlOrEmptySchema(),
+  formats: z.array(ReleaseFormatSchema),
+  genres: z.array(z.string()).optional(),
+  master_id: z.number().optional(),
+  master_url: urlOrEmptySchema().nullable().optional(),
+  labels: z.array(LabelBasicSchema),
+  resource_url: urlOrEmptySchema(),
+  styles: z.array(z.string()).optional(),
+  thumb: urlOrEmptySchema(),
+  title: z.string(),
+  year: z.number()
+});
+var ReleaseSchema = z.object({
+  id: z.number().int(),
+  artists_sort: z.string().optional(),
+  artists: z.array(ArtistBasicSchema),
+  blocked_from_sale: z.boolean().optional(),
+  companies: z.array(
+    z.object({
+      id: z.number().int().optional(),
+      catno: z.string().optional(),
+      entity_type: z.string().optional(),
+      entity_type_name: z.string().optional(),
+      name: z.string().optional(),
+      resource_url: urlOrEmptySchema().optional(),
+      thumbnail_url: urlOrEmptySchema().optional()
+    })
+  ).optional(),
+  community: z.object({
+    contributors: z.array(
+      z.object({
+        resource_url: urlOrEmptySchema().optional(),
+        username: z.string().optional()
+      })
+    ).optional(),
+    data_quality: z.string().optional(),
+    have: z.number().int().optional(),
+    rating: z.object({
+      average: z.number().optional(),
+      count: z.number().int().optional()
+    }).optional(),
+    status: z.string().optional(),
+    submitter: z.object({
+      resource_url: urlOrEmptySchema().optional(),
+      username: z.string().optional()
+    }).optional(),
+    want: z.number().int().optional()
+  }).optional(),
+  country: z.string().optional(),
+  data_quality: z.string().optional(),
+  date_added: z.string().optional(),
+  date_changed: z.string().optional(),
+  estimated_weight: z.number().int().optional(),
+  extraartists: z.array(ArtistBasicSchema).optional(),
+  format_quantity: z.number().int().optional(),
+  formats: z.array(ReleaseFormatSchema).optional(),
+  genres: z.array(z.string()).optional(),
+  identifiers: z.array(
+    z.object({
+      type: z.string(),
+      value: z.string(),
+      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(),
+  labels: z.array(LabelBasicSchema).optional(),
+  lowest_price: z.number().optional(),
+  master_id: z.number().optional(),
+  master_url: urlOrEmptySchema().optional(),
+  notes: z.string().optional(),
+  num_for_sale: z.number().int().optional(),
+  released: z.string().optional(),
+  released_formatted: z.string().optional(),
+  resource_url: urlOrEmptySchema(),
+  series: z.array(z.unknown()).optional(),
+  status: z.string().optional(),
+  styles: z.array(z.string()).optional(),
+  thumb: urlOrEmptySchema().optional(),
+  title: z.string(),
+  tracklist: z.array(
+    z.object({
+      duration: z.string().optional(),
+      position: z.string(),
+      title: z.string(),
+      type_: z.string().optional(),
+      extraartists: z.array(ArtistBasicSchema).optional()
+    })
+  ).optional(),
+  uri: urlOrEmptySchema().optional(),
+  videos: z.array(
+    z.object({
+      description: z.string().nullable().optional(),
+      duration: z.number().int().optional(),
+      embed: z.boolean().optional(),
+      title: z.string().optional(),
+      uri: urlOrEmptySchema().optional()
+    })
+  ).optional(),
+  year: z.number()
+});
+var ReleaseIdParamSchema = z.object({
+  release_id: z.number().min(1, "The release_id must be non-zero")
+});
+var ReleaseParamsSchema = ReleaseIdParamSchema.extend({
+  curr_abbr: CurrencyCodeSchema.optional()
+});
+var ReleaseRatingSchema = UsernameInputSchema.merge(ReleaseIdParamSchema).extend({
+  rating: z.number()
+});
+var ReleaseRatingCommunitySchema = ReleaseIdParamSchema.extend({
+  rating: z.object({
+    average: z.number(),
+    count: z.number().int()
+  })
+});
+var ReleaseRatingParamsSchema = UsernameInputSchema.merge(ReleaseIdParamSchema);
+var ReleaseRatingEditParamsSchema = ReleaseRatingParamsSchema.extend({
+  rating: z.number().int().min(1, "The rating must be at least 1").max(5, "The rating must be at most 5")
+});
+
+// src/types/master.ts
+var MasterReleaseIdParamSchema = z.object({
+  master_id: z.number().int()
+});
+var MasterReleaseSchema = ReleaseSchema.extend({
+  main_release: z.number(),
+  most_recent_release: z.number(),
+  versions_url: urlOrEmptySchema(),
+  main_release_url: urlOrEmptySchema(),
+  most_recent_release_url: urlOrEmptySchema(),
+  tracklist: z.array(
+    z.object({
+      position: z.string(),
+      type_: z.string().optional(),
+      title: z.string(),
+      duration: z.string().optional(),
+      extraartists: z.array(ArtistBasicSchema).optional()
+    })
+  ).optional(),
+  artists: z.array(
+    ArtistBasicSchema.extend({
+      thumbnail_url: urlOrEmptySchema().optional()
+    })
+  )
+});
+
+// src/services/master.ts
+var MasterReleaseService = class extends DiscogsService {
+  constructor() {
+    super("/masters");
+  }
+  /**
+   * Get a master release
+   *
+   * @param params - Parameters containing the master release ID
+   * @returns {MasterRelease} The master release information
+   * @throws {DiscogsResourceNotFoundError} If the master release cannot be found
+   * @throws {Error} If there's an unexpected error
+   */
+  async get({ master_id }) {
+    try {
+      const response = await this.request(`/${master_id}`);
+      const validatedResponse = MasterReleaseSchema.parse(response);
+      return validatedResponse;
+    } catch (error) {
+      if (isDiscogsError(error)) {
+        throw error;
+      }
+      throw new Error(`Failed to get master release: ${String(error)}`);
+    }
+  }
+};
+
+// src/services/release.ts
+var ReleaseService = class extends DiscogsService {
+  constructor() {
+    super("/releases");
+  }
+  /**
+   * Deletes the release's rating for a given user
+   *
+   * @param params - Parameters for the request
+   * @throws {DiscogsAuthenticationError} If authentication fails
+   * @throws {DiscogsPermissionError} If trying to delete a release rating of another user
+   * @throws {DiscogsResourceNotFoundError} If the release or user cannot be found
+   * @throws {Error} If there's an unexpected error
+   */
+  async deleteRatingByUser({ username, release_id }) {
+    try {
+      await this.request(`/${release_id}/rating/${username}`, {
+        method: "DELETE"
+      });
+    } catch (error) {
+      if (isDiscogsError(error)) {
+        throw error;
+      }
+      throw new Error(`Failed to delete release rating: ${String(error)}`);
+    }
+  }
+  /**
+   * Updates the release's rating for a given user
+   *
+   * @param params - Parameters for the request
+   * @returns {ReleaseRating} The updated release rating
+   * @throws {DiscogsAuthenticationError} If authentication fails
+   * @throws {DiscogsPermissionError} If trying to edit a release rating of another user
+   * @throws {DiscogsResourceNotFoundError} If the release or user cannot be found
+   * @throws {Error} If there's an unexpected error
+   */
+  async editRatingByUser({
+    username,
+    release_id,
+    rating
+  }) {
+    try {
+      const response = await this.request(`/${release_id}/rating/${username}`, {
+        method: "PUT",
+        body: { rating }
+      });
+      const validatedResponse = ReleaseRatingSchema.parse(response);
+      return validatedResponse;
+    } catch (error) {
+      if (isDiscogsError(error)) {
+        throw error;
+      }
+      throw new Error(`Failed to edit release rating: ${String(error)}`);
+    }
+  }
+  /**
+   * Get a release
+   *
+   * @param params - Parameters for the request
+   * @returns {Release} The release information
+   * @throws {DiscogsResourceNotFoundError} If the release cannot be found
+   * @throws {Error} If there's an unexpected error
+   */
+  async get({ release_id, ...options }) {
+    try {
+      const response = await this.request(`/${release_id}`, {
+        params: options
+      });
+      const validatedResponse = ReleaseSchema.parse(response);
+      return validatedResponse;
+    } catch (error) {
+      if (isDiscogsError(error)) {
+        throw error;
+      }
+      throw new Error(`Failed to get release: ${String(error)}`);
+    }
+  }
+  /**
+   * Retrieves the community release rating average and count
+   *
+   * @param params - Parameters for the request
+   * @returns {ReleaseRatingCommunity} The release community rating
+   * @throws {DiscogsResourceNotFoundError} If the release cannot be found
+   * @throws {Error} If there's an unexpected error
+   */
+  async getCommunityRating({ release_id }) {
+    try {
+      const response = await this.request(`/${release_id}/rating`);
+      const validatedResponse = ReleaseRatingCommunitySchema.parse(response);
+      return validatedResponse;
+    } catch (error) {
+      if (isDiscogsError(error)) {
+        throw error;
+      }
+      throw new Error(`Failed to get release community rating: ${String(error)}`);
+    }
+  }
+  /**
+   * Retrieves the release's rating for a given user
+   *
+   * @param params - Parameters for the request
+   * @returns {ReleaseRating} The release rating
+   * @throws {DiscogsResourceNotFoundError} If the release or user cannot be found
+   * @throws {Error} If there's an unexpected error
+   */
+  async getRatingByUser({ username, release_id }) {
+    try {
+      const response = await this.request(`/${release_id}/rating/${username}`);
+      const validatedResponse = ReleaseRatingSchema.parse(response);
+      return validatedResponse;
+    } catch (error) {
+      if (isDiscogsError(error)) {
+        throw error;
+      }
+      throw new Error(`Failed to get release rating: ${String(error)}`);
+    }
+  }
+};
+
+// src/tools/database.ts
+var deleteReleaseRatingTool = {
+  name: "delete_release_rating",
+  description: `Deletes the release's rating for a given user`,
+  parameters: ReleaseRatingParamsSchema,
+  execute: async (args) => {
+    try {
+      const releaseService = new ReleaseService();
+      await releaseService.deleteRatingByUser(args);
+      return "Release rating deleted successfully";
+    } catch (error) {
+      throw formatDiscogsError(error);
+    }
+  }
+};
+var editReleaseRatingTool = {
+  name: "edit_release_rating",
+  description: `Updates the release's rating for a given user`,
+  parameters: ReleaseRatingEditParamsSchema,
+  execute: async (args) => {
+    try {
+      const releaseService = new ReleaseService();
+      const releaseRating = await releaseService.editRatingByUser(args);
+      return JSON.stringify(releaseRating);
+    } catch (error) {
+      throw formatDiscogsError(error);
+    }
+  }
+};
+var getArtistTool = {
+  name: "get_artist",
+  description: "Get an artist",
+  parameters: ArtistIdParamSchema,
+  execute: async (args) => {
+    try {
+      const artistService = new ArtistService();
+      const artist = await artistService.get(args);
+      return JSON.stringify(artist);
+    } catch (error) {
+      throw formatDiscogsError(error);
+    }
+  }
+};
+var getArtistReleasesTool = {
+  name: "get_artist_releases",
+  description: `Get an artist's releases`,
+  parameters: ArtistReleasesParamsSchema,
+  execute: async (args) => {
+    try {
+      const artistService = new ArtistService();
+      const artistReleases = await artistService.getReleases(args);
+      return JSON.stringify(artistReleases);
+    } catch (error) {
+      throw formatDiscogsError(error);
+    }
+  }
+};
+var getLabelTool = {
+  name: "get_label",
+  description: "Get a label",
+  parameters: LabelIdParamSchema,
+  execute: async (args) => {
+    try {
+      const labelService = new LabelService();
+      const label = await labelService.get(args);
+      return JSON.stringify(label);
+    } catch (error) {
+      throw formatDiscogsError(error);
+    }
+  }
+};
+var getLabelReleasesTool = {
+  name: "get_label_releases",
+  description: "Returns a list of Releases associated with the label",
+  parameters: LabelReleasesParamsSchema,
+  execute: async (args) => {
+    try {
+      const labelService = new LabelService();
+      const labelReleases = await labelService.getReleases(args);
+      return JSON.stringify(labelReleases);
+    } catch (error) {
+      throw formatDiscogsError(error);
+    }
+  }
+};
+var getMasterReleaseTool = {
+  name: "get_master_release",
+  description: "Get a master release",
+  parameters: MasterReleaseIdParamSchema,
+  execute: async (args) => {
+    try {
+      const masterReleaseService = new MasterReleaseService();
+      const masterRelease = await masterReleaseService.get(args);
+      return JSON.stringify(masterRelease);
+    } catch (error) {
+      throw formatDiscogsError(error);
+    }
+  }
+};
+var getReleaseTool = {
+  name: "get_release",
+  description: "Get a release",
+  parameters: ReleaseParamsSchema,
+  execute: async (args) => {
+    try {
+      const releaseService = new ReleaseService();
+      const release = await releaseService.get(args);
+      return JSON.stringify(release);
+    } catch (error) {
+      throw formatDiscogsError(error);
+    }
+  }
+};
+var getReleaseCommunityRatingTool = {
+  name: "get_release_community_rating",
+  description: "Retrieves the release community rating average and count",
+  parameters: ReleaseIdParamSchema,
+  execute: async (args) => {
+    try {
+      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(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 }) => {
+    try {
+      return imageContent({ url });
+    } catch (error) {
+      throw formatDiscogsError(error);
+    }
+  }
+};
+function registerMediaTools(server) {
+  server.addTool(fetchImageTool);
+}
+var FolderIdParamSchema = (min) => z.object({
+  folder_id: z.number().int().min(min ?? 0)
+});
+var UserCollectionCustomFieldsSchema = z.object({
+  fields: z.array(
+    z.object({
+      id: z.number().int(),
+      lines: z.number().int().optional(),
+      name: z.string(),
+      options: z.array(z.string()).optional(),
+      position: z.number().int(),
+      public: z.boolean(),
+      type: z.string()
+    })
+  )
+});
+var UserCollectionFolderSchema = z.object({
+  id: z.number(),
+  count: z.number(),
+  name: z.string(),
+  resource_url: z.string().url()
+});
+var UserCollectionFoldersSchema = z.object({
+  folders: z.array(UserCollectionFolderSchema)
+});
+var UserCollectionFolderCreateParamsSchema = UsernameInputSchema.extend({
+  name: z.string().optional()
+});
+var UserCollectionFolderEditParamsSchema = UserCollectionFolderCreateParamsSchema.merge(FolderIdParamSchema());
+var UserCollectionFolderParamsSchema = UsernameInputSchema.merge(FolderIdParamSchema());
+var UserCollectionFolderReleaseParamsSchema = UsernameInputSchema.merge(
+  FolderIdParamSchema(1).merge(ReleaseIdParamSchema)
+);
+var UserCollectionItemsParamsSchema = UsernameInputSchema.merge(
+  FolderIdParamSchema().merge(
+    QueryParamsSchema([
+      "added",
+      "artist",
+      "catno",
+      "format",
+      "label",
+      "rating",
+      "title",
+      "year"
+    ])
+  )
+);
+var UserCollectionReleaseAddedSchema = z.object({
+  instance_id: z.number().int(),
+  resource_url: z.string().url()
+});
+var UserCollectionReleaseParamsSchema = UsernameInputSchema.merge(
+  ReleaseIdParamSchema.merge(QueryParamsSchema())
+);
+var UserCollectionReleaseDeletedParamsSchema = UserCollectionFolderReleaseParamsSchema.extend({
+  instance_id: z.number().int()
+});
+var UserCollectionReleaseItemSchema = z.object({
+  id: z.number(),
+  instance_id: z.number(),
+  basic_information: BasicInformationSchema,
+  date_added: z.string().optional(),
+  folder_id: z.number(),
+  notes: z.array(
+    z.object({
+      field_id: z.number(),
+      value: z.string()
+    })
+  ).optional(),
+  rating: z.number().int().optional()
+});
+var UserCollectionReleaseRatingParamsSchema = UserCollectionReleaseDeletedParamsSchema.extend({
+  rating: z.number().int().min(1).max(5).optional()
+});
+var UserCollectionMoveReleaseParamsSchema = UserCollectionReleaseDeletedParamsSchema.extend({
+  destination_folder_id: z.number()
+});
+var UserCollectionItemsByReleaseSchema = PaginatedResponseSchema(
+  UserCollectionReleaseItemSchema,
+  "releases"
+);
+var UserCollectionValueSchema = z.object({
+  maximum: z.string(),
+  median: z.string(),
+  minimum: z.string()
+});
+var UserListItemSchema = z.object({
+  id: z.number(),
+  date_added: z.string(),
+  date_changed: z.string(),
+  description: z.string().optional(),
+  name: z.string(),
+  public: z.boolean(),
+  resource_url: z.string().url(),
+  uri: z.string().url()
+});
+var UserListsParamsSchema = UsernameInputSchema.merge(QueryParamsSchema());
+var UserListsSchema = PaginatedResponseSchema(UserListItemSchema, "lists");
+var UserProfileSchema = z.object({
+  id: z.number(),
+  resource_url: z.string().url(),
+  uri: z.string().url(),
+  username: z.string(),
+  name: z.string(),
+  home_page: z.string(),
+  location: z.string(),
+  profile: z.string(),
+  registered: z.string(),
+  rank: z.number(),
+  num_pending: z.number(),
+  num_for_sale: z.number(),
+  num_lists: z.number(),
+  releases_contributed: z.number(),
+  releases_rated: z.number(),
+  rating_avg: z.number(),
+  inventory_url: z.string().url(),
+  collection_folders_url: z.string().url(),
+  collection_fields_url: z.string().url(),
+  wantlist_url: z.string().url(),
+  avatar_url: z.string().url(),
+  curr_abbr: z.string(),
+  activated: z.boolean(),
+  marketplace_suspended: z.boolean(),
+  banner_url: z.string(),
+  buyer_rating: z.number(),
+  buyer_rating_stars: z.number(),
+  buyer_num_ratings: z.number(),
+  seller_rating: z.number(),
+  seller_rating_stars: z.number(),
+  seller_num_ratings: z.number(),
+  is_staff: z.boolean(),
+  // Optional fields that may appear in some responses
+  email: z.string().email().optional(),
+  num_collection: z.number().optional(),
+  num_wantlist: z.number().optional(),
+  num_unread: z.number().optional()
+});
+var UserProfileEditInputSchema = z.object({
+  ...UsernameInputSchema.shape,
+  name: z.string().optional(),
+  home_page: urlOrEmptySchema().optional(),
+  location: z.string().optional(),
+  profile: z.string().optional(),
+  curr_abbr: CurrencyCodeSchema.optional()
+});
+var UserWantlistParamsSchema = UsernameInputSchema.merge(
+  QueryParamsSchema(["added", "artist", "label", "rating", "title", "year"])
+);
+var UserWantlistItemSchema = z.object({
+  id: z.number(),
+  basic_information: BasicInformationSchema,
+  notes: z.string().optional(),
+  rating: z.number().int().min(0).max(5).optional(),
+  resource_url: z.string().url()
+});
+var UserWantlistSchema = PaginatedResponseSchema(UserWantlistItemSchema, "wants");
+var UserWantlistItemParamsSchema = UsernameInputSchema.merge(
+  ReleaseIdParamSchema.extend({
+    notes: z.string().optional(),
+    rating: z.number().int().min(0).max(5).optional()
+  })
+);
+
+// src/services/user/collection.ts
+var UserCollectionService = class extends BaseUserService {
+  /**
+   * Add a release to a folder in a user's collection. The folder_id must be non-zero.
+   *
+   * @param params The parameters for the release addition
+   * @returns {UserCollectionReleaseAdded} The added release
+   * @throws {DiscogsAuthenticationError} If authentication fails
+   * @throws {DiscogsPermissionError} If trying to add a release to a folder of another user
+   * @throws {DiscogsResourceNotFoundError} If the username, folder_id, or release_id cannot be found
+   * @throws {DiscogsValidationFailedError} If the folder_id is 0
+   * @throws {Error} If there's an unexpected error
+   */
+  async addReleaseToFolder({
+    username,
+    folder_id,
+    release_id
+  }) {
+    try {
+      const response = await this.request(
+        `/${username}/collection/folders/${folder_id}/releases/${release_id}`,
+        {
+          method: "POST"
+        }
+      );
+      const validatedResponse = UserCollectionReleaseAddedSchema.parse(response);
+      return validatedResponse;
+    } catch (error) {
+      if (isDiscogsError(error)) {
+        throw error;
+      }
+      throw new Error(`Failed to add release to folder: ${String(error)}`);
+    }
+  }
+  /**
+   * Create a new folder in a user's collection
+   *
+   * @param params The parameters for the folder creation
+   * @returns {UserCollectionFolder} The created folder
+   * @throws {DiscogsAuthenticationError} If authentication fails
+   * @throws {DiscogsPermissionError} If trying to create a folder for another user
+   * @throws {DiscogsResourceNotFoundError} If the username cannot be found
+   * @throws {Error} If there's an unexpected error
+   */
+  async createFolder({
+    username,
+    ...body
+  }) {
+    try {
+      const response = await this.request(`/${username}/collection/folders`, {
+        method: "POST",
+        body
+      });
+      const validatedResponse = UserCollectionFolderSchema.parse(response);
+      return validatedResponse;
+    } catch (error) {
+      if (isDiscogsError(error)) {
+        throw error;
+      }
+      throw new Error(`Failed to create folder: ${String(error)}`);
+    }
+  }
+  /**
+   * Delete a folder from a user's collection. A folder must be empty before it can be deleted.
+   *
+   * @param params The parameters for the folder deletion
+   * @throws {DiscogsAuthenticationError} If authentication fails
+   * @throws {DiscogsPermissionError} If trying to delete a folder of another user
+   * @throws {DiscogsResourceNotFoundError} If the username or folder cannot be found
+   * @throws {DiscogsValidationFailedError} If the folder is not empty
+   * @throws {Error} If there's an unexpected error
+   */
+  async deleteFolder({ username, folder_id }) {
+    try {
+      await this.request(`/${username}/collection/folders/${folder_id}`, {
+        method: "DELETE"
+      });
+    } catch (error) {
+      if (isDiscogsError(error)) {
+        throw error;
+      }
+      throw new Error(`Failed to delete folder: ${String(error)}`);
+    }
+  }
+  /**
+   * Remove an instance of a release from a user's collection folder
+   *
+   * @param params The parameters for the release deletion
+   * @throws {DiscogsAuthenticationError} If authentication fails
+   * @throws {DiscogsPermissionError} If trying to delete a release from a folder of another user
+   * @throws {DiscogsResourceNotFoundError} If the username, folder_id, release_id, or instance_id cannot be found
+   * @throws {DiscogsValidationFailedError} If the folder_id is 0
+   * @throws {Error} If there's an unexpected error
+   */
+  async deleteReleaseFromFolder({
+    username,
+    folder_id,
+    release_id,
+    instance_id
+  }) {
+    try {
+      await this.request(
+        `/${username}/collection/folders/${folder_id}/releases/${release_id}/instances/${instance_id}`,
+        {
+          method: "DELETE"
+        }
+      );
+    } catch (error) {
+      if (isDiscogsError(error)) {
+        throw error;
+      }
+      throw new Error(`Failed to delete release from folder: ${String(error)}`);
+    }
+  }
+  /**
+   * Edit a folder's metadata. Folders 0 and 1 cannot be renamed.
+   *
+   * @param params The parameters for the folder edit
+   * @returns {UserCollectionFolder} The edited folder
+   * @throws {DiscogsAuthenticationError} If authentication fails
+   * @throws {DiscogsPermissionError} If trying to edit a folder of another user
+   * @throws {DiscogsResourceNotFoundError} If the username or folder cannot be found
+   * @throws {DiscogsValidationFailedError} If the folder_id is 0 or 1
+   * @throws {Error} If there's an unexpected error
+   */
+  async editFolder({
+    username,
+    folder_id,
+    ...body
+  }) {
+    try {
+      const response = await this.request(
+        `/${username}/collection/folders/${folder_id}`,
+        {
+          method: "POST",
+          body
+        }
+      );
+      const validatedResponse = UserCollectionFolderSchema.parse(response);
+      return validatedResponse;
+    } catch (error) {
+      if (isDiscogsError(error)) {
+        throw error;
+      }
+      throw new Error(`Failed to edit folder: ${String(error)}`);
+    }
+  }
+  /**
+   * Find a release in a user's collection
+   *
+   * @param params The parameters for the release search
+   * @returns {UserCollectionItemsByRelease} The releases in the user's collection
+   * @throws {DiscogsAuthenticationError} If authentication fails
+   * @throws {DiscogsPermissionError} If trying to search a private collection
+   * @throws {DiscogsResourceNotFoundError} If the username cannot be found
+   * @throws {Error} If there's an unexpected error
+   */
+  async findRelease({
+    username,
+    release_id,
+    ...options
+  }) {
+    try {
+      const response = await this.request(
+        `/${username}/collection/releases/${release_id}`,
+        {
+          params: options
+        }
+      );
+      const validatedResponse = UserCollectionItemsByReleaseSchema.parse(response);
+      return validatedResponse;
+    } catch (error) {
+      if (isDiscogsError(error)) {
+        throw error;
+      }
+      throw new Error(`Failed to find release in collection: ${String(error)}`);
+    }
+  }
+  /**
+   * Retrieve a list of user-defined collection notes fields. These fields are available on every release in the collection.
+   *
+   * @param username The username of whose collection custom fields you are requesting
+   * @returns {UserCollectionCustomFields} The user's collection custom fields
+   * @throws {DiscogsAuthenticationError} If authentication fails
+   * @throws {DiscogsPermissionError} If trying to get custom fields of a private collection
+   * @throws {DiscogsResourceNotFoundError} If the username cannot be found
+   * @throws {Error} If there's an unexpected error
+   */
+  async getCustomFields({ username }) {
+    try {
+      const response = await this.request(
+        `/${username}/collection/fields`
+      );
+      const validatedResponse = UserCollectionCustomFieldsSchema.parse(response);
+      return validatedResponse;
+    } catch (error) {
+      if (isDiscogsError(error)) {
+        throw error;
+      }
+      throw new Error(`Failed to get collection custom fields: ${String(error)}`);
+    }
+  }
+  /**
+   * Retrieve a list of folders in a user's collection
+   *
+   * @param username The username of whose collection folders you are requesting
+   * @returns {UserCollectionFolder[]} The user's collection folders
+   * @throws {DiscogsAuthenticationError} If authentication fails
+   * @throws {DiscogsPermissionError} If another user's collection does not have public folders
+   * @throws {DiscogsResourceNotFoundError} If the username cannot be found
+   * @throws {Error} If there's an unexpected error
+   */
+  async getFolders({ username }) {
+    try {
+      const response = await this.request(`/${username}/collection/folders`);
+      const validatedResponse = UserCollectionFoldersSchema.parse(response);
+      return validatedResponse;
+    } catch (error) {
+      if (isDiscogsError(error)) {
+        throw error;
+      }
+      throw new Error(`Failed to get collection folders: ${String(error)}`);
+    }
+  }
+  /**
+   * Retrieve metadata about a folder in a user's collection
+   *
+   * @param params The parameters for the folder retrieval
+   * @returns {UserCollectionFolder} The retrieved folder
+   * @throws {DiscogsAuthenticationError} If authentication fails
+   * @throws {DiscogsPermissionError} If trying to get a private folder of another user
+   * @throws {DiscogsResourceNotFoundError} If the username or folder cannot be found
+   * @throws {Error} If there's an unexpected error
+   */
+  async getFolder({
+    username,
+    folder_id
+  }) {
+    try {
+      const response = await this.request(
+        `/${username}/collection/folders/${folder_id}`
+      );
+      const validatedResponse = UserCollectionFolderSchema.parse(response);
+      return validatedResponse;
+    } catch (error) {
+      if (isDiscogsError(error)) {
+        throw error;
+      }
+      throw new Error(`Failed to get folder: ${String(error)}`);
+    }
+  }
+  /**
+   * Returns the list of item in a folder in a user's collection
+   *
+   * @param params The parameters for the item retrieval
+   * @returns {UserCollectionItemsByRelease} The items in the user's collection
+   * @throws {DiscogsAuthenticationError} If authentication fails
+   * @throws {DiscogsPermissionError} If trying to get a private collection
+   * @throws {DiscogsResourceNotFoundError} If the username or folder cannot be found
+   * @throws {Error} If there's an unexpected error
+   */
+  async getItems({
+    username,
+    folder_id,
+    ...options
+  }) {
+    try {
+      const response = await this.request(
+        `/${username}/collection/folders/${folder_id}/releases`,
+        {
+          params: options
+        }
+      );
+      const validatedResponse = UserCollectionItemsByReleaseSchema.parse(response);
+      return validatedResponse;
+    } catch (error) {
+      if (isDiscogsError(error)) {
+        throw error;
+      }
+      throw new Error(`Failed to get collection items: ${String(error)}`);
+    }
+  }
+  /**
+   * Returns the minimum, median, and maximum value of a user's collection
+   *
+   * @param username The username of whose collection value you are requesting
+   * @returns {UserCollectionValue} The user's collection value
+   * @throws {DiscogsAuthenticationError} If authentication fails
+   * @throws {DiscogsPermissionError} If trying to get the collection value of another user
+   * @throws {DiscogsResourceNotFoundError} If the username cannot be found
+   * @throws {Error} If there's an unexpected error
+   */
+  async getValue({ username }) {
+    try {
+      const response = await this.request(`/${username}/collection/value`);
+      const validatedResponse = UserCollectionValueSchema.parse(response);
+      return validatedResponse;
+    } catch (error) {
+      if (isDiscogsError(error)) {
+        throw error;
+      }
+      throw new Error(`Failed to get collection value: ${String(error)}`);
+    }
+  }
+  /**
+   * Move a release in a user's collection to another folder
+   *
+   * @param params The parameters for the release move
+   * @throws {DiscogsAuthenticationError} If authentication fails
+   * @throws {DiscogsPermissionError} If trying to move a collection release of another user
+   * @throws {DiscogsResourceNotFoundError} If the user, source folder, destination folder, release, or instance cannot be found
+   * @throws {Error} If there's an unexpected error
+   */
+  async moveRelease({
+    username,
+    folder_id,
+    release_id,
+    instance_id,
+    ...body
+  }) {
+    try {
+      await this.request(
+        `/${username}/collection/folders/${folder_id}/releases/${release_id}/instances/${instance_id}`,
+        {
+          method: "POST",
+          body: { folder_id: body.destination_folder_id }
+        }
+      );
+    } catch (error) {
+      if (isDiscogsError(error)) {
+        throw error;
+      }
+      throw new Error(`Failed to move release: ${String(error)}`);
+    }
+  }
+  /**
+   * Rate a release in a user's collection
+   *
+   * @param params The parameters for the release rating
+   * @throws {DiscogsAuthenticationError} If authentication fails
+   * @throws {DiscogsPermissionError} If trying to rate a collection release of another user
+   * @throws {DiscogsResourceNotFoundError} If the username, folder_id, release_id, or instance_id cannot be found
+   * @throws {Error} If there's an unexpected error
+   */
+  async rateRelease({
+    username,
+    folder_id,
+    release_id,
+    instance_id,
+    ...body
+  }) {
+    try {
+      await this.request(
+        `/${username}/collection/folders/${folder_id}/releases/${release_id}/instances/${instance_id}`,
+        {
+          method: "POST",
+          body
+        }
+      );
+    } catch (error) {
+      if (isDiscogsError(error)) {
+        throw error;
+      }
+      throw new Error(`Failed to rate release: ${String(error)}`);
+    }
+  }
+};
+
+// src/services/user/lists.ts
+var UserListsService = class extends BaseUserService {
+  /**
+   * Get a user's lists
+   * @param params - Parameters for the request including username and optional pagination/sorting
+   * @returns {UserLists} A paginated response containing the user's lists
+   * @throws {DiscogsAuthenticationError} If authentication fails
+   * @throws {DiscogsResourceNotFoundError} If the username cannot be found
+   * @throws {Error} If there's a validation error or other unexpected error
+   */
+  async get({ username, ...options }) {
+    try {
+      const response = await this.request(`/${username}/lists`, {
+        params: options
+      });
+      const validatedResponse = UserListsSchema.parse(response);
+      return validatedResponse;
+    } catch (error) {
+      if (isDiscogsError(error)) {
+        throw error;
+      }
+      throw new Error(`Failed to get lists: ${String(error)}`);
+    }
+  }
+};
+
+// src/services/user/profile.ts
+var UserProfileService = class extends BaseUserService {
+  /**
+   * Retrieve a user by username
+   *
+   * @param username The username of whose profile you are requesting
+   * @returns {UserProfile} The user's profile information
+   * @throws {DiscogsAuthenticationError} If authentication fails
+   * @throws {DiscogsResourceNotFoundError} If the username cannot be found
+   * @throws {Error} If there's a validation error or other unexpected error
+   */
+  async get({ username }) {
+    try {
+      const response = await this.request(`/${username}`);
+      const validatedResponse = UserProfileSchema.parse(response);
+      return validatedResponse;
+    } catch (error) {
+      if (isDiscogsError(error)) {
+        throw error;
+      }
+      throw new Error(`Failed to get profile: ${String(error)}`);
+    }
+  }
+  /**
+   * Edit a user's profile data
+   *
+   * @param params UserProfileEditInput
+   * @returns {UserProfile} The user's profile information
+   * @throws {DiscogsAuthenticationError} If authentication fails
+   * @throws {DiscogsPermissionError} If trying to edit a profile that is not the authenticated user
+   * @throws {DiscogsResourceNotFoundError} If the username cannot be found
+   * @throws {Error} If there's a validation error or other unexpected error
+   */
+  async edit({ username, ...body }) {
+    try {
+      const response = await this.request(`/${username}`, {
+        method: "POST",
+        body
+      });
+      const validatedResponse = UserProfileSchema.parse(response);
+      return validatedResponse;
+    } catch (error) {
+      if (isDiscogsError(error)) {
+        throw error;
+      }
+      throw new Error(`Failed to edit profile: ${String(error)}`);
+    }
+  }
+};
+
+// src/services/user/wants.ts
+var UserWantsService = class extends BaseUserService {
+  /**
+   * Returns the list of releases in a user's wantlist
+   *
+   * @param params - Parameters for the wantlist request including username and optional pagination/sorting
+   * @returns {UserWantlist} The user's wantlist with pagination metadata
+   * @throws {DiscogsAuthenticationError} If authentication fails
+   * @throws {DiscogsPermissionError} If trying to get the private wantlist of another user
+   * @throws {DiscogsResourceNotFoundError} If the username cannot be found
+   * @throws {Error} If there's a validation error or other unexpected error
+   */
+  async getList({ username, ...options }) {
+    try {
+      const response = await this.request(`/${username}/wants`, {
+        params: options
+      });
+      const validatedResponse = UserWantlistSchema.parse(response);
+      return validatedResponse;
+    } catch (error) {
+      if (isDiscogsError(error)) {
+        throw error;
+      }
+      throw new Error(`Failed to get wantlist: ${String(error)}`);
+    }
+  }
+  /**
+   * Add a release to a user's wantlist
+   *
+   * @param params - Parameters for adding a release to wantlist
+   * @returns {UserWantlistItem} The added wantlist item
+   * @throws {DiscogsAuthenticationError} If authentication fails
+   * @throws {DiscogsPermissionError} If trying to add to another user's wantlist
+   * @throws {DiscogsResourceNotFoundError} If the username or release_id cannot be found
+   * @throws {Error} If there's a validation error or other unexpected error
+   */
+  async addItem({
+    username,
+    release_id,
+    ...body
+  }) {
+    try {
+      const response = await this.request(`/${username}/wants/${release_id}`, {
+        method: "PUT",
+        body
+      });
+      const validatedResponse = UserWantlistItemSchema.parse(response);
+      return validatedResponse;
+    } catch (error) {
+      if (isDiscogsError(error)) {
+        throw error;
+      }
+      throw new Error(`Failed to add to wantlist: ${String(error)}`);
+    }
+  }
+  /**
+   * Edit a release in a user's wantlist
+   *
+   * @param params - Parameters for editing a release in a wantlist
+   * @returns {UserWantlistItem} The edited wantlist item
+   * @throws {DiscogsAuthenticationError} If authentication fails
+   * @throws {DiscogsPermissionError} If trying to edit a release in another user's wantlist
+   * @throws {DiscogsResourceNotFoundError} If the username or release_id cannot be found
+   * @throws {Error} If there's a validation error or other unexpected error
+   */
+  async editItem({
+    username,
+    release_id,
+    ...body
+  }) {
+    try {
+      const response = await this.request(`/${username}/wants/${release_id}`, {
+        method: "POST",
+        body
+      });
+      const validatedResponse = UserWantlistItemSchema.parse(response);
+      return validatedResponse;
+    } catch (error) {
+      if (isDiscogsError(error)) {
+        throw error;
+      }
+      throw new Error(`Failed to add to wantlist: ${String(error)}`);
+    }
+  }
+  /**
+   * Delete a release from a user's wantlist
+   *
+   * @param params - Parameters for deleting a release from wantlist including username and release_id
+   * @throws {DiscogsAuthenticationError} If authentication fails
+   * @throws {DiscogsPermissionError} If trying to delete from another user's wantlist
+   * @throws {DiscogsResourceNotFoundError} If the username or release_id cannot be found
+   * @throws {Error} If there's an unexpected error
+   */
+  async deleteItem({ username, release_id }) {
+    try {
+      await this.request(`/${username}/wants/${release_id}`, {
+        method: "DELETE"
+      });
+    } catch (error) {
+      if (isDiscogsError(error)) {
+        throw error;
+      }
+      throw new Error(`Failed to delete from wantlist: ${String(error)}`);
+    }
+  }
+};
+
+// src/services/user/index.ts
+var UserService = class {
+  collection;
+  lists;
+  profile;
+  wants;
+  constructor() {
+    this.collection = new UserCollectionService();
+    this.lists = new UserListsService();
+    this.profile = new UserProfileService();
+    this.wants = new UserWantsService();
+  }
+};
+
+// src/tools/userCollection.ts
+var addReleaseToUserCollectionFolderTool = {
+  name: "add_release_to_user_collection_folder",
+  description: `Add a release to a folder in a user's collection. The folder_id must be non-zero.`,
+  parameters: UserCollectionFolderReleaseParamsSchema,
+  execute: async (args) => {
+    try {
+      const userService = new UserService();
+      const release = await userService.collection.addReleaseToFolder(args);
+      return JSON.stringify(release);
+    } catch (error) {
+      throw formatDiscogsError(error);
+    }
+  }
+};
+var createUserCollectionFolderTool = {
+  name: "create_user_collection_folder",
+  description: `Create a new folder in a user's collection`,
+  parameters: UserCollectionFolderCreateParamsSchema,
+  execute: async (args) => {
+    try {
+      const userService = new UserService();
+      const folder = await userService.collection.createFolder(args);
+      return JSON.stringify(folder);
+    } catch (error) {
+      throw formatDiscogsError(error);
+    }
+  }
+};
+var deleteReleaseFromUserCollectionFolderTool = {
+  name: "delete_release_from_user_collection_folder",
+  description: `Remove an instance of a release from a user's collection folder. The folder_id must be non-zero.`,
+  parameters: UserCollectionReleaseDeletedParamsSchema,
+  execute: async (args) => {
+    try {
+      const userService = new UserService();
+      await userService.collection.deleteReleaseFromFolder(args);
+      return "Release deleted successfully";
+    } catch (error) {
+      throw formatDiscogsError(error);
+    }
+  }
+};
+var deleteUserCollectionFolderTool = {
+  name: "delete_user_collection_folder",
+  description: `Delete a folder from a user's collection. A folder must be empty before it can be deleted.`,
+  parameters: UserCollectionFolderParamsSchema,
+  execute: async (args) => {
+    try {
+      const userService = new UserService();
+      await userService.collection.deleteFolder(args);
+      return "Folder deleted successfully";
+    } catch (error) {
+      throw formatDiscogsError(error);
+    }
+  }
+};
+var editUserCollectionFolderTool = {
+  name: "edit_user_collection_folder",
+  description: `Edit a folder's metadata. Folders 0 and 1 cannot be renamed.`,
+  parameters: UserCollectionFolderEditParamsSchema,
+  execute: async (args) => {
+    try {
+      const userService = new UserService();
+      const folder = await userService.collection.editFolder(args);
+      return JSON.stringify(folder);
+    } catch (error) {
+      throw formatDiscogsError(error);
+    }
+  }
+};
+var findReleaseInUserCollectionTool = {
+  name: "find_release_in_user_collection",
+  description: `Find a release in a user's collection`,
+  parameters: UserCollectionReleaseParamsSchema,
+  execute: async (args) => {
+    try {
+      const userService = new UserService();
+      const releases = await userService.collection.findRelease(args);
+      return JSON.stringify(releases);
+    } catch (error) {
+      throw formatDiscogsError(error);
+    }
+  }
+};
+var getUserCollectionCustomFieldsTool = {
+  name: "get_user_collection_custom_fields",
+  description: `Retrieve a list of user-defined collection notes fields. These fields are available on every release in the collection.`,
+  parameters: UsernameInputSchema,
+  execute: async (args) => {
+    try {
+      const userService = new UserService();
+      const customFields = await userService.collection.getCustomFields(args);
+      return JSON.stringify(customFields);
+    } catch (error) {
+      throw formatDiscogsError(error);
+    }
+  }
+};
+var getUserCollectionFolderTool = {
+  name: "get_user_collection_folder",
+  description: `Retrieve metadata about a folder in a user's collection`,
+  parameters: UserCollectionFolderParamsSchema,
+  execute: async (args) => {
+    try {
+      const userService = new UserService();
+      const folder = await userService.collection.getFolder(args);
+      return JSON.stringify(folder);
+    } catch (error) {
+      throw formatDiscogsError(error);
+    }
+  }
+};
+var getUserCollectionFoldersTool = {
+  name: "get_user_collection_folders",
+  description: `Retrieve a list of folders in a user's collection`,
+  parameters: UsernameInputSchema,
+  execute: async (args) => {
+    try {
+      const userService = new UserService();
+      const collectionFolders = await userService.collection.getFolders(args);
+      return JSON.stringify(collectionFolders);
+    } catch (error) {
+      throw formatDiscogsError(error);
+    }
+  }
+};
+var getUserCollectionItemsTool = {
+  name: "get_user_collection_items",
+  description: `Retrieve a list of items in a user's collection`,
+  parameters: UserCollectionItemsParamsSchema,
+  execute: async (args) => {
+    try {
+      const userService = new UserService();
+      const items = await userService.collection.getItems(args);
+      return JSON.stringify(items);
+    } catch (error) {
+      throw formatDiscogsError(error);
+    }
+  }
+};
+var getUserCollectionValueTool = {
+  name: "get_user_collection_value",
+  description: `Returns the minimum, median, and maximum value of a user's collection`,
+  parameters: UsernameInputSchema,
+  execute: async (args) => {
+    try {
+      const userService = new UserService();
+      const collectionValue = await userService.collection.getValue(args);
+      return JSON.stringify(collectionValue);
+    } catch (error) {
+      throw formatDiscogsError(error);
+    }
+  }
+};
+var moveReleaseInUserCollectionTool = {
+  name: "move_release_in_user_collection",
+  description: `Move a release in a user's collection to another folder`,
+  parameters: UserCollectionMoveReleaseParamsSchema,
+  execute: async (args) => {
+    try {
+      const userService = new UserService();
+      await userService.collection.moveRelease(args);
+      return "Release moved successfully";
+    } catch (error) {
+      throw formatDiscogsError(error);
+    }
+  }
+};
+var rateReleaseInUserCollectionTool = {
+  name: "rate_release_in_user_collection",
+  description: `Rate a release in a user's collection. The folder_id must be non-zero.`,
+  parameters: UserCollectionReleaseRatingParamsSchema,
+  execute: async (args) => {
+    try {
+      const userService = new UserService();
+      await userService.collection.rateRelease(args);
+      return "Release rated successfully";
+    } catch (error) {
+      throw formatDiscogsError(error);
+    }
+  }
+};
+function registerUserCollectionTools(server) {
+  server.addTool(getUserCollectionFoldersTool);
+  server.addTool(createUserCollectionFolderTool);
+  server.addTool(getUserCollectionFolderTool);
+  server.addTool(editUserCollectionFolderTool);
+  server.addTool(deleteUserCollectionFolderTool);
+  server.addTool(findReleaseInUserCollectionTool);
+  server.addTool(getUserCollectionItemsTool);
+  server.addTool(addReleaseToUserCollectionFolderTool);
+  server.addTool(rateReleaseInUserCollectionTool);
+  server.addTool(moveReleaseInUserCollectionTool);
+  server.addTool(deleteReleaseFromUserCollectionFolderTool);
+  server.addTool(getUserCollectionCustomFieldsTool);
+  server.addTool(getUserCollectionValueTool);
+}
+var DiscogsUserIdentitySchema = z.object({
+  id: z.number(),
+  username: z.string(),
+  resource_url: z.string().url(),
+  consumer_name: z.string()
+});
+
+// src/services/oauth.ts
+var OAuthService = class extends DiscogsService {
+  constructor() {
+    super("/oauth");
+  }
+  /**
+   * Get the identity of the authenticated user
+   * @returns The user's identity information
+   * @throws {DiscogsAuthenticationError} If authentication fails (401)
+   */
+  async getUserIdentity() {
+    try {
+      const response = await this.request("/identity");
+      const validatedResponse = DiscogsUserIdentitySchema.parse(response);
+      return validatedResponse;
+    } catch (error) {
+      if (isDiscogsError(error)) {
+        throw error;
+      }
+      throw new Error(`Failed to get identity: ${String(error)}`);
+    }
+  }
+};
+
+// src/tools/userIdentity.ts
+var getUserIdentityTool = {
+  name: "get_user_identity",
+  description: "Retrieve basic information about the authenticated user",
+  parameters: z.object({}),
+  execute: async () => {
+    try {
+      const oauthService = new OAuthService();
+      const identity = await oauthService.getUserIdentity();
+      return JSON.stringify(identity);
+    } catch (error) {
+      throw formatDiscogsError(error);
+    }
+  }
+};
+var getUserProfileTool = {
+  name: "get_user_profile",
+  description: "Retrieve a user by username",
+  parameters: UsernameInputSchema,
+  execute: async (args) => {
+    try {
+      const userService = new UserService();
+      const profile = await userService.profile.get(args);
+      return JSON.stringify(profile);
+    } catch (error) {
+      throw formatDiscogsError(error);
+    }
+  }
+};
+var editUserProfileTool = {
+  name: "edit_user_profile",
+  description: `Edit a user's profile data`,
+  parameters: UserProfileEditInputSchema,
+  execute: async (args) => {
+    try {
+      const userService = new UserService();
+      const profile = await userService.profile.edit(args);
+      return JSON.stringify(profile);
+    } catch (error) {
+      throw formatDiscogsError(error);
+    }
+  }
+};
+function registerUserIdentityTools(server) {
+  server.addTool(getUserIdentityTool);
+  server.addTool(getUserProfileTool);
+  server.addTool(editUserProfileTool);
+}
+var ListItemSchema = z.object({
+  id: z.number(),
+  comment: z.string().optional(),
+  display_title: z.string(),
+  image_url: z.string().url(),
+  resource_url: z.string().url(),
+  stats: z.object({
+    community: z.object({
+      in_collection: z.number(),
+      in_wantlist: z.number()
+    }),
+    user: z.object({
+      in_collection: z.number(),
+      in_wantlist: z.number()
+    })
+  }),
+  type: z.string(),
+  uri: z.string().url()
+});
+var ListSchema = z.object({
+  id: z.number(),
+  user: z.object({
+    id: z.number(),
+    avatar_url: z.string().url(),
+    username: z.string(),
+    resource_url: z.string().url()
+  }),
+  name: z.string(),
+  description: z.string().optional(),
+  public: z.boolean(),
+  date_added: z.string(),
+  date_changed: z.string(),
+  uri: z.string().url(),
+  resource_url: z.string().url(),
+  image_url: z.string().url().optional(),
+  items: z.array(ListItemSchema)
+});
+var ListIdParamSchema = z.object({
+  list_id: z.number()
+});
+
+// src/services/list.ts
+var ListService = class extends DiscogsService {
+  constructor() {
+    super("/lists");
+  }
+  /**
+   * Returns items from a specified List
+   *
+   * @param params - Parameters containing the list ID
+   * @returns {List} The list information
+   * @throws {DiscogsPermissionError} If the user doesn't have permission to access the list
+   * @throws {DiscogsResourceNotFoundError} If the list cannot be found
+   * @throws {Error} If there's a validation error or other unexpected error
+   */
+  async getList({ list_id }) {
+    try {
+      const response = await this.request(`/${list_id}`);
+      const validatedResponse = ListSchema.parse(response);
+      return validatedResponse;
+    } catch (error) {
+      if (isDiscogsError(error)) {
+        throw error;
+      }
+      throw new Error(`Failed to get list: ${String(error)}`);
+    }
+  }
+};
+
+// src/tools/userLists.ts
+var getUserListsTool = {
+  name: "get_user_lists",
+  description: `Get a user's lists`,
+  parameters: UserListsParamsSchema,
+  execute: async (args) => {
+    try {
+      const userService = new UserService();
+      const lists = await userService.lists.get(args);
+      return JSON.stringify(lists);
+    } catch (error) {
+      throw formatDiscogsError(error);
+    }
+  }
+};
+var getListTool = {
+  name: "get_list",
+  description: `Get a list by ID`,
+  parameters: ListIdParamSchema,
+  execute: async (args) => {
+    try {
+      const listService = new ListService();
+      const list = await listService.getList(args);
+      return JSON.stringify(list);
+    } catch (error) {
+      throw formatDiscogsError(error);
+    }
+  }
+};
+function registerUserListsTools(server) {
+  server.addTool(getUserListsTool);
+  server.addTool(getListTool);
+}
+
+// src/tools/userWantlist.ts
+var getUserWantlistTool = {
+  name: "get_user_wantlist",
+  description: `Returns the list of releases in a user's wantlist`,
+  parameters: UserWantlistParamsSchema,
+  execute: async (args) => {
+    try {
+      const userService = new UserService();
+      const wantlist = await userService.wants.getList(args);
+      return JSON.stringify(wantlist);
+    } catch (error) {
+      throw formatDiscogsError(error);
+    }
+  }
+};
+var addToWantlistTool = {
+  name: "add_to_wantlist",
+  description: `Add a release to a user's wantlist`,
+  parameters: UserWantlistItemParamsSchema,
+  execute: async (args) => {
+    try {
+      const userService = new UserService();
+      const wantlistItem = await userService.wants.addItem(args);
+      return JSON.stringify(wantlistItem);
+    } catch (error) {
+      throw formatDiscogsError(error);
+    }
+  }
+};
+var editItemInWantlistTool = {
+  name: "edit_item_in_wantlist",
+  description: `Edit a release in a user's wantlist`,
+  parameters: UserWantlistItemParamsSchema,
+  execute: async (args) => {
+    try {
+      const userService = new UserService();
+      const wantlistItem = await userService.wants.editItem(args);
+      return JSON.stringify(wantlistItem);
+    } catch (error) {
+      throw formatDiscogsError(error);
+    }
+  }
+};
+var deleteItemInWantlistTool = {
+  name: "delete_item_in_wantlist",
+  description: `Delete a release from a user's wantlist`,
+  parameters: UserWantlistItemParamsSchema,
+  execute: async (args) => {
+    try {
+      const userService = new UserService();
+      await userService.wants.deleteItem(args);
+      return "Release deleted from wantlist";
+    } catch (error) {
+      throw formatDiscogsError(error);
+    }
+  }
+};
+function registerUserWantlistTools(server) {
+  server.addTool(getUserWantlistTool);
+  server.addTool(addToWantlistTool);
+  server.addTool(editItemInWantlistTool);
+  server.addTool(deleteItemInWantlistTool);
+}
+
+// src/tools/index.ts
+function registerTools(server) {
+  registerDatabaseTools(server);
+  registerUserIdentityTools(server);
+  registerUserCollectionTools(server);
+  registerUserWantlistTools(server);
+  registerUserListsTools(server);
+  registerMediaTools(server);
+}
+
+// src/index.ts
+function assertTransportType(transportType) {
+  return transportType === "stdio" || transportType === "sse";
+}
+try {
+  validateConfig();
+  const transportType = process.argv[2] ?? "stdio";
+  if (!assertTransportType(transportType)) {
+    throw Error(`Invalid transport type: "${transportType}". Allowed: 'stdio' (default) or 'sse'.`);
+  }
+  const server = new FastMCP({
+    name: config.server.name,
+    version: VERSION
+  });
+  registerTools(server);
+  if (transportType === "stdio") {
+    server.start({ transportType });
+  } else if (transportType === "sse") {
+    server.start({
+      transportType,
+      sse: {
+        endpoint: "/sse",
+        port: config.server.port
+      }
+    });
+  }
+  log.info(`${config.server.name} started with transport type: ${transportType}`);
+} catch (error) {
+  log.error(`Failed to run the ${config.server.name}: `, error);
+  process.exit(1);
+}
+process.on("SIGINT", () => {
+  log.info("Shutting down server...");
+  process.exit(0);
+});
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map