npm - @mediagraph/mcp - Versions diffs - 1.0.0 - Mend

@mediagraph/mcp 1.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (5) hide show

package/dist/index.js ADDED Viewed

@@ -0,0 +1,3185 @@
+#!/usr/bin/env node
+// src/index.ts
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  CallToolRequestSchema,
+  ListResourcesRequestSchema,
+  ListResourceTemplatesRequestSchema,
+  ListToolsRequestSchema,
+  ReadResourceRequestSchema
+} from "@modelcontextprotocol/sdk/types.js";
+// src/auth/oauth.ts
+import { createHash, randomBytes } from "crypto";
+import { createServer } from "http";
+import { URL as URL2 } from "url";
+var OAuthHandler = class {
+  config;
+  codeVerifier = null;
+  state = null;
+  callbackServer = null;
+  constructor(config2) {
+    this.config = {
+      clientId: config2.clientId,
+      clientSecret: config2.clientSecret,
+      oauthUrl: config2.oauthUrl || "https://mediagraph.io",
+      redirectPort: config2.redirectPort || 52584,
+      scopes: config2.scopes || ["read", "write"]
+    };
+  }
+  /**
+   * Generate PKCE code verifier and challenge
+   */
+  generatePKCE() {
+    const verifier = randomBytes(32).toString("base64url");
+    const challenge = createHash("sha256").update(verifier).digest("base64url");
+    return { verifier, challenge };
+  }
+  /**
+   * Generate a random state parameter
+   */
+  generateState() {
+    return randomBytes(16).toString("base64url");
+  }
+  /**
+   * Get the redirect URI
+   */
+  getRedirectUri() {
+    return `http://localhost:${this.config.redirectPort}/callback`;
+  }
+  /**
+   * Build the authorization URL for OAuth flow
+   */
+  getAuthorizationUrl() {
+    const { verifier, challenge } = this.generatePKCE();
+    this.codeVerifier = verifier;
+    this.state = this.generateState();
+    const params = new URLSearchParams({
+      response_type: "code",
+      client_id: this.config.clientId,
+      redirect_uri: this.getRedirectUri(),
+      scope: this.config.scopes.join(" "),
+      state: this.state,
+      code_challenge: challenge,
+      code_challenge_method: "S256"
+    });
+    return `${this.config.oauthUrl}/oauth/authorize?${params.toString()}`;
+  }
+  /**
+   * Start a local HTTP server to receive the OAuth callback
+   */
+  async waitForCallback() {
+    return new Promise((resolve, reject) => {
+      this.callbackServer = createServer((req, res) => {
+        const url = new URL2(req.url || "/", `http://localhost:${this.config.redirectPort}`);
+        if (url.pathname === "/callback") {
+          const code = url.searchParams.get("code");
+          const state = url.searchParams.get("state");
+          const error = url.searchParams.get("error");
+          const errorDescription = url.searchParams.get("error_description");
+          if (error) {
+            res.writeHead(400, { "Content-Type": "text/html" });
+            res.end(`
+              <html>
+                <body style="font-family: sans-serif; padding: 40px; text-align: center;">
+                  <h1 style="color: #dc3545;">Authorization Failed</h1>
+                  <p>${errorDescription || error}</p>
+                  <p>You can close this window.</p>
+                </body>
+              </html>
+            `);
+            this.stopCallbackServer();
+            reject(new Error(errorDescription || error));
+            return;
+          }
+          if (!code || !state) {
+            res.writeHead(400, { "Content-Type": "text/html" });
+            res.end(`
+              <html>
+                <body style="font-family: sans-serif; padding: 40px; text-align: center;">
+                  <h1 style="color: #dc3545;">Invalid Callback</h1>
+                  <p>Missing authorization code or state.</p>
+                  <p>You can close this window.</p>
+                </body>
+              </html>
+            `);
+            this.stopCallbackServer();
+            reject(new Error("Missing authorization code or state"));
+            return;
+          }
+          if (state !== this.state) {
+            res.writeHead(400, { "Content-Type": "text/html" });
+            res.end(`
+              <html>
+                <body style="font-family: sans-serif; padding: 40px; text-align: center;">
+                  <h1 style="color: #dc3545;">Security Error</h1>
+                  <p>State parameter mismatch. This could indicate a CSRF attack.</p>
+                  <p>You can close this window.</p>
+                </body>
+              </html>
+            `);
+            this.stopCallbackServer();
+            reject(new Error("State parameter mismatch"));
+            return;
+          }
+          res.writeHead(200, { "Content-Type": "text/html" });
+          res.end(`
+            <html>
+              <body style="font-family: sans-serif; padding: 40px; text-align: center;">
+                <h1 style="color: #28a745;">Authorization Successful</h1>
+                <p>You have successfully connected to Mediagraph.</p>
+                <p>You can close this window and return to your application.</p>
+              </body>
+            </html>
+          `);
+          this.stopCallbackServer();
+          resolve({ code, state });
+        } else {
+          res.writeHead(404);
+          res.end("Not found");
+        }
+      });
+      this.callbackServer.listen(this.config.redirectPort, () => {
+      });
+      setTimeout(() => {
+        this.stopCallbackServer();
+        reject(new Error("Authorization timed out"));
+      }, 5 * 60 * 1e3);
+    });
+  }
+  /**
+   * Stop the callback server
+   */
+  stopCallbackServer() {
+    if (this.callbackServer) {
+      this.callbackServer.close();
+      this.callbackServer = null;
+    }
+  }
+  /**
+   * Exchange authorization code for tokens
+   */
+  async exchangeCode(code) {
+    if (!this.codeVerifier) {
+      throw new Error("No code verifier available. Start authorization flow first.");
+    }
+    const params = new URLSearchParams({
+      grant_type: "authorization_code",
+      code,
+      redirect_uri: this.getRedirectUri(),
+      client_id: this.config.clientId,
+      code_verifier: this.codeVerifier
+    });
+    if (this.config.clientSecret) {
+      params.append("client_secret", this.config.clientSecret);
+    }
+    const response = await fetch(`${this.config.oauthUrl}/oauth/token`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/x-www-form-urlencoded"
+      },
+      body: params.toString()
+    });
+    if (!response.ok) {
+      const error = await response.json().catch(() => ({ error: "unknown_error" }));
+      throw new Error(`Token exchange failed: ${error.error_description || error.error}`);
+    }
+    const tokenData = await response.json();
+    this.codeVerifier = null;
+    this.state = null;
+    return {
+      ...tokenData,
+      expires_at: Date.now() + tokenData.expires_in * 1e3
+    };
+  }
+  /**
+   * Refresh an access token using a refresh token
+   */
+  async refreshToken(refreshToken) {
+    const params = new URLSearchParams({
+      grant_type: "refresh_token",
+      refresh_token: refreshToken,
+      client_id: this.config.clientId
+    });
+    if (this.config.clientSecret) {
+      params.append("client_secret", this.config.clientSecret);
+    }
+    const response = await fetch(`${this.config.oauthUrl}/oauth/token`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/x-www-form-urlencoded"
+      },
+      body: params.toString()
+    });
+    if (!response.ok) {
+      const error = await response.json().catch(() => ({ error: "unknown_error" }));
+      throw new Error(`Token refresh failed: ${error.error_description || error.error}`);
+    }
+    const tokenData = await response.json();
+    return {
+      ...tokenData,
+      expires_at: Date.now() + tokenData.expires_in * 1e3
+    };
+  }
+  /**
+   * Revoke a token
+   */
+  async revokeToken(token) {
+    const params = new URLSearchParams({
+      token,
+      client_id: this.config.clientId
+    });
+    if (this.config.clientSecret) {
+      params.append("client_secret", this.config.clientSecret);
+    }
+    await fetch(`${this.config.oauthUrl}/oauth/revoke`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/x-www-form-urlencoded"
+      },
+      body: params.toString()
+    });
+  }
+};
+// src/auth/token-store.ts
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
+import { createCipheriv, createDecipheriv, randomBytes as randomBytes2, scryptSync } from "crypto";
+import { homedir } from "os";
+import { join, dirname } from "path";
+var ALGORITHM = "aes-256-gcm";
+var SALT_LENGTH = 16;
+var IV_LENGTH = 12;
+var TAG_LENGTH = 16;
+var TokenStore = class {
+  filePath;
+  encryptionKey = null;
+  constructor(filePath) {
+    this.filePath = filePath || join(homedir(), ".mediagraph", "tokens.enc");
+  }
+  /**
+   * Derive encryption key from a passphrase
+   * In production, this should use system keychain or secure enclave
+   */
+  getEncryptionKey() {
+    if (this.encryptionKey) {
+      return this.encryptionKey;
+    }
+    const machineId = `${homedir()}-mediagraph-mcp`;
+    this.encryptionKey = scryptSync(machineId, "mediagraph-mcp-salt", 32);
+    return this.encryptionKey;
+  }
+  /**
+   * Encrypt data
+   */
+  encrypt(data) {
+    const key = this.getEncryptionKey();
+    const iv = randomBytes2(IV_LENGTH);
+    const salt = randomBytes2(SALT_LENGTH);
+    const cipher = createCipheriv(ALGORITHM, key, iv);
+    const encrypted = Buffer.concat([cipher.update(data, "utf8"), cipher.final()]);
+    const tag = cipher.getAuthTag();
+    return Buffer.concat([salt, iv, tag, encrypted]);
+  }
+  /**
+   * Decrypt data
+   */
+  decrypt(encryptedBuffer) {
+    const key = this.getEncryptionKey();
+    const salt = encryptedBuffer.subarray(0, SALT_LENGTH);
+    const iv = encryptedBuffer.subarray(SALT_LENGTH, SALT_LENGTH + IV_LENGTH);
+    const tag = encryptedBuffer.subarray(SALT_LENGTH + IV_LENGTH, SALT_LENGTH + IV_LENGTH + TAG_LENGTH);
+    const encrypted = encryptedBuffer.subarray(SALT_LENGTH + IV_LENGTH + TAG_LENGTH);
+    const decipher = createDecipheriv(ALGORITHM, key, iv);
+    decipher.setAuthTag(tag);
+    return decipher.update(encrypted) + decipher.final("utf8");
+  }
+  /**
+   * Save tokens to encrypted file
+   */
+  save(data) {
+    const dir = dirname(this.filePath);
+    if (!existsSync(dir)) {
+      mkdirSync(dir, { recursive: true, mode: 448 });
+    }
+    const encrypted = this.encrypt(JSON.stringify(data));
+    writeFileSync(this.filePath, encrypted, { mode: 384 });
+  }
+  /**
+   * Load tokens from encrypted file
+   */
+  load() {
+    if (!existsSync(this.filePath)) {
+      return null;
+    }
+    try {
+      const encrypted = readFileSync(this.filePath);
+      const decrypted = this.decrypt(encrypted);
+      return JSON.parse(decrypted);
+    } catch (error) {
+      console.error("Failed to load tokens:", error);
+      return null;
+    }
+  }
+  /**
+   * Delete stored tokens
+   */
+  clear() {
+    if (existsSync(this.filePath)) {
+      writeFileSync(this.filePath, "", { mode: 384 });
+    }
+  }
+  /**
+   * Check if tokens exist
+   */
+  hasTokens() {
+    return existsSync(this.filePath) && this.load() !== null;
+  }
+  /**
+   * Check if access token is expired or about to expire
+   */
+  isTokenExpired(bufferSeconds = 300) {
+    const data = this.load();
+    if (!data || !data.tokens) {
+      return true;
+    }
+    return Date.now() >= data.tokens.expires_at - bufferSeconds * 1e3;
+  }
+  /**
+   * Get access token, returning null if expired
+   */
+  getAccessToken() {
+    const data = this.load();
+    if (!data || !data.tokens) {
+      return null;
+    }
+    if (this.isTokenExpired()) {
+      return null;
+    }
+    return data.tokens.access_token;
+  }
+  /**
+   * Get refresh token
+   */
+  getRefreshToken() {
+    const data = this.load();
+    return data?.tokens?.refresh_token || null;
+  }
+};
+// src/api/client.ts
+var MediagraphApiError = class extends Error {
+  constructor(statusCode, errorBody) {
+    super(errorBody.message || errorBody.error || "API Error");
+    this.statusCode = statusCode;
+    this.errorBody = errorBody;
+    this.name = "MediagraphApiError";
+  }
+};
+var MediagraphClient = class {
+  apiUrl;
+  getAccessToken;
+  maxRetries = 3;
+  retryDelay = 1e3;
+  constructor(config2) {
+    this.apiUrl = config2.apiUrl || "https://api.mediagraph.io";
+    this.getAccessToken = config2.getAccessToken;
+  }
+  async request(method, path, options = {}) {
+    const token = await this.getAccessToken();
+    if (!token) {
+      throw new Error("Not authenticated. Please authorize with Mediagraph first.");
+    }
+    let url = `${this.apiUrl}${path}`;
+    if (options.params && method === "GET") {
+      const searchParams = new URLSearchParams();
+      for (const [key, value] of Object.entries(options.params)) {
+        if (value !== void 0 && value !== null) {
+          if (Array.isArray(value)) {
+            value.forEach((v) => searchParams.append(`${key}[]`, String(v)));
+          } else {
+            searchParams.append(key, String(value));
+          }
+        }
+      }
+      const queryString = searchParams.toString();
+      if (queryString) {
+        url += `?${queryString}`;
+      }
+    }
+    let lastError = null;
+    for (let attempt = 0; attempt < this.maxRetries; attempt++) {
+      try {
+        const headers = {
+          Authorization: `Bearer ${token}`,
+          "Content-Type": "application/json",
+          Accept: "application/json"
+        };
+        const fetchOptions = {
+          method,
+          headers
+        };
+        if (options.body && method !== "GET") {
+          fetchOptions.body = JSON.stringify(options.body);
+        } else if (options.params && method !== "GET") {
+          fetchOptions.body = JSON.stringify(options.params);
+        }
+        const response = await fetch(url, fetchOptions);
+        if (response.status === 401) {
+          throw new MediagraphApiError(401, {
+            error: "unauthorized",
+            message: "Access token expired or invalid. Please re-authorize."
+          });
+        }
+        if (response.status === 403) {
+          throw new MediagraphApiError(403, {
+            error: "forbidden",
+            message: "You do not have permission to perform this action."
+          });
+        }
+        if (response.status === 404) {
+          throw new MediagraphApiError(404, {
+            error: "not_found",
+            message: "The requested resource was not found."
+          });
+        }
+        if (response.status === 429) {
+          const retryAfter = response.headers.get("Retry-After");
+          const delay = retryAfter ? parseInt(retryAfter, 10) * 1e3 : this.retryDelay * Math.pow(2, attempt);
+          await this.sleep(delay);
+          continue;
+        }
+        if (!response.ok) {
+          let errorBody;
+          try {
+            errorBody = await response.json();
+          } catch {
+            errorBody = { error: "unknown_error", message: response.statusText };
+          }
+          throw new MediagraphApiError(response.status, errorBody);
+        }
+        const contentType = response.headers.get("Content-Type");
+        if (!contentType?.includes("application/json")) {
+          return {};
+        }
+        const data = await response.json();
+        return data;
+      } catch (error) {
+        lastError = error;
+        if (error instanceof MediagraphApiError && [401, 403, 404].includes(error.statusCode)) {
+          throw error;
+        }
+        if (attempt < this.maxRetries - 1) {
+          await this.sleep(this.retryDelay * Math.pow(2, attempt));
+          continue;
+        }
+      }
+    }
+    throw lastError || new Error("Request failed after retries");
+  }
+  sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+  // ============================================================================
+  // User & Organization
+  // ============================================================================
+  async whoami() {
+    return this.request("GET", "/api/whoami");
+  }
+  async getOrganization(id) {
+    return this.request("GET", `/api/organizations/${id}`);
+  }
+  async findOrganization(params) {
+    return this.request("GET", "/api/organizations/find", { params });
+  }
+  // ============================================================================
+  // Memberships
+  // ============================================================================
+  async listMemberships(params) {
+    return this.request("GET", "/api/memberships", { params });
+  }
+  async getMembership(id) {
+    return this.request("GET", `/api/memberships/${id}`);
+  }
+  async updateMembership(id, data) {
+    return this.request("PUT", `/api/memberships/${id}`, { body: { membership: data } });
+  }
+  async updateMembershipStatus(id, status) {
+    return this.request("PUT", `/api/memberships/${id}/update_status`, { body: { status } });
+  }
+  async deleteMembership(id) {
+    await this.request("DELETE", `/api/memberships/${id}`);
+  }
+  // ============================================================================
+  // Assets
+  // ============================================================================
+  async searchAssets(params = {}) {
+    const apiParams = {
+      page: params.page || 1,
+      per_page: params.per_page || 25
+    };
+    const searchKeys = [
+      "q",
+      "ids",
+      "guids",
+      "upload_id",
+      "upload_guid",
+      "storage_folder_id",
+      "omit_child_storage_folders",
+      "collection_id",
+      "omit_child_collections",
+      "lightbox_id",
+      "omit_child_lightboxes",
+      "lightbox_folder_id",
+      "omit_child_lightbox_folders",
+      "tags",
+      "hide_tags",
+      "taxonomy",
+      "hide_taxonomy",
+      "taxonomy_filter_mode",
+      "exts",
+      "rating",
+      "rights",
+      "rights_code",
+      "aspect",
+      "has_people",
+      "has_alt_text",
+      "file_size_range",
+      "gps",
+      "bounds",
+      "captured_at",
+      "missing_captured_at",
+      "created_at",
+      "updated_at",
+      "snapshot_timestamp",
+      "proximity_field",
+      "proximity_word_1",
+      "proximity_word_2",
+      "proximity_max_gaps",
+      "user_ids",
+      "creator_ids",
+      "include_totals",
+      "as_filters",
+      "include_renditions",
+      "include_meta"
+    ];
+    for (const key of searchKeys) {
+      if (params[key] !== void 0) {
+        apiParams[key] = params[key];
+      }
+    }
+    const response = await this.request(
+      "GET",
+      "/api/assets/search",
+      { params: apiParams }
+    );
+    return {
+      assets: response.assets || [],
+      total: response.total || response.assets?.length || 0,
+      page: params.page || 1,
+      per_page: params.per_page || 25,
+      total_pages: Math.ceil((response.total || response.assets?.length || 0) / (params.per_page || 25)),
+      aggs: response.aggs
+    };
+  }
+  async getAsset(id, options) {
+    const params = {};
+    if (options?.include_renditions) params.include_renditions = true;
+    if (options?.include_meta) params.include_meta = true;
+    if (options?.sync) params.sync = true;
+    return this.request("GET", `/api/assets/${id}`, { params });
+  }
+  async updateAsset(id, data) {
+    return this.request("PUT", `/api/assets/${id}`, { body: { asset: data } });
+  }
+  async deleteAsset(id) {
+    await this.request("DELETE", `/api/assets/${id}`);
+  }
+  async getAssetCounts(params) {
+    return this.request("GET", "/api/assets/counts", { params });
+  }
+  async getTrashedAssets(params) {
+    return this.request("GET", "/api/assets/trashed", { params });
+  }
+  async getPopularAssets(params) {
+    return this.request("GET", "/api/assets/popular", { params });
+  }
+  async getUpdatedAssetsSinceLastSync(params) {
+    return this.request("GET", "/api/assets/updated_since_last_sync", { params });
+  }
+  async addTagsToAsset(id, tags) {
+    return this.request("POST", `/api/assets/${id}/tag`, { body: { tags } });
+  }
+  async getAssetAutoTags(id) {
+    return this.request("GET", `/api/assets/${id}/auto_tags`);
+  }
+  async getAssetFaceTaggings(id) {
+    return this.request("GET", `/api/assets/${id}/face_taggings`);
+  }
+  async getAssetDownload(id, rendition) {
+    const params = {};
+    if (rendition) params.rendition = rendition;
+    return this.request("GET", `/api/assets/${id}/download`, { params });
+  }
+  async addAssetVersion(id, data) {
+    return this.request("POST", `/api/assets/${id}/add_version`, { body: data });
+  }
+  async revertAsset(id, versionNumber) {
+    return this.request("POST", `/api/assets/${id}/revert`, { body: { version_number: versionNumber } });
+  }
+  async requestAssetOptimization(id) {
+    return this.request("POST", `/api/assets/${id}/request_optimization`);
+  }
+  async completeAssetOptimization(id) {
+    return this.request("POST", `/api/assets/${id}/complete_optimization`);
+  }
+  async removeAssetOptimizationRequest(id) {
+    return this.request("DELETE", `/api/assets/${id}/remove_optimization_request`);
+  }
+  async updateAssetCollectiveWork(id, data) {
+    return this.request("PUT", `/api/assets/${id}/update_collective_work`, { body: data });
+  }
+  async addAssetsToGroup(assetIds, groupId, groupType) {
+    await this.request("POST", "/api/assets/add_group", {
+      body: { asset_ids: assetIds, group_id: groupId, group_type: groupType }
+    });
+  }
+  // ============================================================================
+  // Asset Data Versions
+  // ============================================================================
+  async getAssetDataVersions(assetId) {
+    return this.request("GET", `/api/assets/${assetId}/asset_data_versions`);
+  }
+  async getAssetDataVersion(assetId, versionNumber) {
+    return this.request("GET", `/api/assets/${assetId}/asset_data_versions/${versionNumber}`);
+  }
+  // ============================================================================
+  // Collections
+  // ============================================================================
+  async listCollections(params) {
+    return this.request("GET", "/api/collections", { params });
+  }
+  async getCollection(id) {
+    return this.request("GET", `/api/collections/${id}`);
+  }
+  async createCollection(data) {
+    return this.request("POST", "/api/collections", { body: { collection: data } });
+  }
+  async updateCollection(id, data) {
+    return this.request("PUT", `/api/collections/${id}`, { body: { collection: data } });
+  }
+  async deleteCollection(id) {
+    await this.request("DELETE", `/api/collections/${id}`);
+  }
+  async findCollection(params) {
+    return this.request("GET", "/api/collections/find", { params });
+  }
+  async getCollectionsTree() {
+    return this.request("GET", "/api/collections/tree");
+  }
+  async getCollectionVisibleAssetCounts(ids) {
+    return this.request("GET", "/api/collections/visible_asset_counts", { params: { ids } });
+  }
+  async addAssetToCollection(collectionId, assetId) {
+    await this.request("POST", `/api/collections/${collectionId}/add_asset`, { body: { asset_id: assetId } });
+  }
+  // ============================================================================
+  // Lightboxes
+  // ============================================================================
+  async listLightboxes(params) {
+    return this.request("GET", "/api/lightboxes", { params });
+  }
+  async getLightbox(id) {
+    return this.request("GET", `/api/lightboxes/${id}`);
+  }
+  async createLightbox(data) {
+    return this.request("POST", "/api/lightboxes", { body: { lightbox: data } });
+  }
+  async updateLightbox(id, data) {
+    return this.request("PUT", `/api/lightboxes/${id}`, { body: { lightbox: data } });
+  }
+  async deleteLightbox(id) {
+    await this.request("DELETE", `/api/lightboxes/${id}`);
+  }
+  async getLightboxesTree() {
+    return this.request("GET", "/api/lightboxes/tree");
+  }
+  async transferLightboxOwnership(id, userId) {
+    return this.request("POST", `/api/lightboxes/${id}/transfer_ownership`, { body: { user_id: userId } });
+  }
+  async addAssetToLightbox(lightboxId, assetId) {
+    await this.request("POST", `/api/lightboxes/${lightboxId}/add_asset`, { body: { asset_id: assetId } });
+  }
+  // ============================================================================
+  // Storage Folders
+  // ============================================================================
+  async listStorageFolders(params) {
+    return this.request("GET", "/api/storage_folders", { params });
+  }
+  async getStorageFolder(id) {
+    return this.request("GET", `/api/storage_folders/${id}`);
+  }
+  async createStorageFolder(data) {
+    return this.request("POST", "/api/storage_folders", { body: { storage_folder: data } });
+  }
+  async updateStorageFolder(id, data) {
+    return this.request("PUT", `/api/storage_folders/${id}`, { body: { storage_folder: data } });
+  }
+  async deleteStorageFolder(id) {
+    await this.request("DELETE", `/api/storage_folders/${id}`);
+  }
+  async getStorageFoldersTree() {
+    return this.request("GET", "/api/storage_folders/tree");
+  }
+  async getStorageFolderAssetIds(id) {
+    return this.request("GET", `/api/storage_folders/${id}/asset_ids`);
+  }
+  // ============================================================================
+  // Tags
+  // ============================================================================
+  async listTags(params) {
+    return this.request("GET", "/api/tags", { params });
+  }
+  async getTag(id) {
+    return this.request("GET", `/api/tags/${id}`);
+  }
+  async createTag(data) {
+    return this.request("POST", "/api/tags", { body: { tag: data } });
+  }
+  async updateTag(id, data) {
+    return this.request("PUT", `/api/tags/${id}`, { body: { tag: data } });
+  }
+  async deleteTag(id) {
+    await this.request("DELETE", `/api/tags/${id}`);
+  }
+  async bulkFindTags(names) {
+    return this.request("POST", "/api/tags/bulk_find", { body: { names } });
+  }
+  async addTagToTaxonomy(id, taxonomyId) {
+    return this.request("POST", `/api/tags/${id}/add_taxonomy`, { body: { taxonomy_id: taxonomyId } });
+  }
+  async mergeTagInto(id, targetTagId) {
+    await this.request("POST", `/api/tags/${id}/merge_into`, { body: { target_tag_id: targetTagId } });
+  }
+  async getTagEvents(params) {
+    return this.request("GET", "/api/tags/events", { params });
+  }
+  // ============================================================================
+  // Auto Tags
+  // ============================================================================
+  async listAutoTags(params) {
+    return this.request("GET", "/api/auto_tags", { params });
+  }
+  async getAutoTag(id) {
+    return this.request("GET", `/api/auto_tags/${id}`);
+  }
+  async bulkFindAutoTags(names) {
+    return this.request("POST", "/api/auto_tags/bulk_find", { body: { names } });
+  }
+  // ============================================================================
+  // Taggings
+  // ============================================================================
+  async getTagging(id) {
+    return this.request("GET", `/api/taggings/${id}`);
+  }
+  async deleteTagging(id) {
+    await this.request("DELETE", `/api/taggings/${id}`);
+  }
+  // ============================================================================
+  // Taxonomies
+  // ============================================================================
+  async listTaxonomies(params) {
+    return this.request("GET", "/api/taxonomies", { params });
+  }
+  async getTaxonomy(id) {
+    return this.request("GET", `/api/taxonomies/${id}`);
+  }
+  async createTaxonomy(data) {
+    return this.request("POST", "/api/taxonomies", { body: { taxonomy: data } });
+  }
+  async updateTaxonomy(id, data) {
+    return this.request("PUT", `/api/taxonomies/${id}`, { body: { taxonomy: data } });
+  }
+  async deleteTaxonomy(id) {
+    await this.request("DELETE", `/api/taxonomies/${id}`);
+  }
+  // ============================================================================
+  // Taxonomy Tags
+  // ============================================================================
+  async listTaxonomyTags(taxonomyId, params) {
+    return this.request("GET", `/api/taxonomies/${taxonomyId}/taxonomy_tags`, { params });
+  }
+  async getTaxonomyTag(taxonomyId, id) {
+    return this.request("GET", `/api/taxonomies/${taxonomyId}/taxonomy_tags/${id}`);
+  }
+  async createTaxonomyTag(taxonomyId, data) {
+    return this.request("POST", `/api/taxonomies/${taxonomyId}/taxonomy_tags`, { body: { taxonomy_tag: data } });
+  }
+  async updateTaxonomyTag(taxonomyId, id, data) {
+    return this.request("PUT", `/api/taxonomies/${taxonomyId}/taxonomy_tags/${id}`, { body: { taxonomy_tag: data } });
+  }
+  async deleteTaxonomyTag(taxonomyId, id) {
+    await this.request("DELETE", `/api/taxonomies/${taxonomyId}/taxonomy_tags/${id}`);
+  }
+  async getTaxonomyTagsTree(taxonomyId) {
+    return this.request("GET", `/api/taxonomies/${taxonomyId}/taxonomy_tags/tree`);
+  }
+  // ============================================================================
+  // Creator Tags
+  // ============================================================================
+  async listCreatorTags(params) {
+    return this.request("GET", "/api/creator_tags", { params });
+  }
+  async getCreatorTag(id) {
+    return this.request("GET", `/api/creator_tags/${id}`);
+  }
+  async createCreatorTag(data) {
+    return this.request("POST", "/api/creator_tags", { body: { creator_tag: data } });
+  }
+  async updateCreatorTag(id, data) {
+    return this.request("PUT", `/api/creator_tags/${id}`, { body: { creator_tag: data } });
+  }
+  async deleteCreatorTag(id) {
+    await this.request("DELETE", `/api/creator_tags/${id}`);
+  }
+  async findCreatorTag(params) {
+    return this.request("GET", "/api/creator_tags/find", { params });
+  }
+  // ============================================================================
+  // Rights Packages
+  // ============================================================================
+  async listRightsPackages(params) {
+    return this.request("GET", "/api/rights_packages", { params });
+  }
+  async getRightsPackage(id) {
+    return this.request("GET", `/api/rights_packages/${id}`);
+  }
+  async createRightsPackage(data) {
+    return this.request("POST", "/api/rights_packages", { body: { rights_package: data } });
+  }
+  async updateRightsPackage(id, data) {
+    return this.request("PUT", `/api/rights_packages/${id}`, { body: { rights_package: data } });
+  }
+  async deleteRightsPackage(id) {
+    await this.request("DELETE", `/api/rights_packages/${id}`);
+  }
+  async bulkFindRightsPackages(ids) {
+    return this.request("POST", "/api/rights_packages/bulk_find", { body: { ids } });
+  }
+  // ============================================================================
+  // Permissions
+  // ============================================================================
+  async listPermissions(params) {
+    return this.request("GET", "/api/permissions", { params });
+  }
+  async getPermission(id) {
+    return this.request("GET", `/api/permissions/${id}`);
+  }
+  async createPermission(data) {
+    return this.request("POST", "/api/permissions", { body: { permission: data } });
+  }
+  async updatePermission(id, data) {
+    return this.request("PUT", `/api/permissions/${id}`, { body: { permission: data } });
+  }
+  async deletePermission(id) {
+    await this.request("DELETE", `/api/permissions/${id}`);
+  }
+  // ============================================================================
+  // Share Links
+  // ============================================================================
+  async listShareLinks(params) {
+    return this.request("GET", "/api/share_links", { params });
+  }
+  async getShareLink(id) {
+    return this.request("GET", `/api/share_links/${id}`);
+  }
+  async createShareLink(data) {
+    return this.request("POST", "/api/share_links", { body: { share_link: data } });
+  }
+  async updateShareLink(id, data) {
+    return this.request("PUT", `/api/share_links/${id}`, { body: { share_link: data } });
+  }
+  async deleteShareLink(id) {
+    await this.request("DELETE", `/api/share_links/${id}`);
+  }
+  async getAssetGroupShareLinks(assetGroupId) {
+    return this.request("GET", `/api/asset_groups/${assetGroupId}/share_links`);
+  }
+  // ============================================================================
+  // Shares
+  // ============================================================================
+  async listShares(params) {
+    return this.request("GET", "/api/shares", { params });
+  }
+  async getShare(id) {
+    return this.request("GET", `/api/shares/${id}`);
+  }
+  async createShare(data) {
+    return this.request("POST", "/api/shares", { body: { share: data } });
+  }
+  async deleteShare(id) {
+    await this.request("DELETE", `/api/shares/${id}`);
+  }
+  // ============================================================================
+  // Collection Shares
+  // ============================================================================
+  async listCollectionShares(params) {
+    return this.request("GET", "/api/collection_shares", { params });
+  }
+  async getCollectionShare(id) {
+    return this.request("GET", `/api/collection_shares/${id}`);
+  }
+  async createCollectionShare(data) {
+    return this.request("POST", "/api/collection_shares", { body: { collection_share: data } });
+  }
+  async deleteCollectionShare(id) {
+    await this.request("DELETE", `/api/collection_shares/${id}`);
+  }
+  async getCollectionSharesTree() {
+    return this.request("GET", "/api/collection_shares/tree");
+  }
+  // ============================================================================
+  // Access Requests
+  // ============================================================================
+  async listAccessRequests(params) {
+    return this.request("GET", "/api/access_requests", { params });
+  }
+  async getAccessRequest(id) {
+    return this.request("GET", `/api/access_requests/${id}`);
+  }
+  async createAccessRequest(data) {
+    return this.request("POST", "/api/access_requests", { body: { access_request: data } });
+  }
+  async updateAccessRequest(id, data) {
+    return this.request("PUT", `/api/access_requests/${id}`, { body: { access_request: data } });
+  }
+  async deleteAccessRequest(id) {
+    await this.request("DELETE", `/api/access_requests/${id}`);
+  }
+  async submitAccessRequest(id) {
+    return this.request("POST", `/api/access_requests/${id}/submit`);
+  }
+  async findAccessRequest(params) {
+    return this.request("GET", "/api/access_requests/find", { params });
+  }
+  async getAccessRequestsTree() {
+    return this.request("GET", "/api/access_requests/tree");
+  }
+  // ============================================================================
+  // Uploads
+  // ============================================================================
+  async listUploads(params) {
+    return this.request("GET", "/api/uploads", { params });
+  }
+  async createUpload() {
+    return this.request("POST", "/api/uploads");
+  }
+  async getUploadAssets(guid, params) {
+    return this.request("GET", `/api/uploads/${guid}/assets`, { params });
+  }
+  async addAssetsToUpload(guid, assetIds) {
+    await this.request("POST", `/api/uploads/${guid}/assets`, { body: { asset_ids: assetIds } });
+  }
+  async setUploadDone(id) {
+    return this.request("POST", `/api/uploads/${id}/set_done`);
+  }
+  async canUpload() {
+    return this.request("GET", "/api/can_upload");
+  }
+  // ============================================================================
+  // Contributions
+  // ============================================================================
+  async listContributions(params) {
+    return this.request("GET", "/api/contributions", { params });
+  }
+  async getContribution(id) {
+    return this.request("GET", `/api/contributions/${id}`);
+  }
+  async createContribution(data) {
+    return this.request("POST", "/api/contributions", { body: { contribution: data } });
+  }
+  async updateContribution(id, data) {
+    return this.request("PUT", `/api/contributions/${id}`, { body: { contribution: data } });
+  }
+  async deleteContribution(id) {
+    await this.request("DELETE", `/api/contributions/${id}`);
+  }
+  async findContribution(params) {
+    return this.request("GET", "/api/contributions/find", { params });
+  }
+  async getFeaturedContributions() {
+    return this.request("GET", "/api/contributions/featured");
+  }
+  async getContributionUploads(contributionId, params) {
+    return this.request("GET", `/api/contributions/${contributionId}/uploads`, { params });
+  }
+  async getContributionGroup() {
+    return this.request("GET", "/api/contributions/group");
+  }
+  async getContributionLightbox() {
+    return this.request("GET", "/api/contributions/lightbox");
+  }
+  async getContributionLink() {
+    return this.request("GET", "/api/contributions/link");
+  }
+  // ============================================================================
+  // Bulk Jobs
+  // ============================================================================
+  async listBulkJobs(params) {
+    return this.request("GET", "/api/bulk_jobs", { params });
+  }
+  async getBulkJob(id) {
+    return this.request("GET", `/api/bulk_jobs/${id}`);
+  }
+  async createBulkJob(data) {
+    return this.request("POST", "/api/bulk_jobs", { body: { bulk_job: data } });
+  }
+  async getBulkJobAssets(id, params) {
+    return this.request("GET", `/api/bulk_jobs/${id}/assets`, { params });
+  }
+  async cancelBulkJob(id) {
+    return this.request("POST", `/api/bulk_jobs/${id}/cancel`);
+  }
+  async getBulkJobQueuePosition(id) {
+    return this.request("GET", `/api/bulk_jobs/${id}/queue_position`);
+  }
+  async getProcessingBulkJobs() {
+    return this.request("GET", "/api/bulk_jobs/processing");
+  }
+  async previewCaiBulkJob(data) {
+    return this.request("POST", "/api/bulk_jobs/cai_preview", { body: data });
+  }
+  // ============================================================================
+  // Custom Meta Fields
+  // ============================================================================
+  async listCustomMetaFields(params) {
+    return this.request("GET", "/api/custom_meta_fields", { params });
+  }
+  async getCustomMetaField(id) {
+    return this.request("GET", `/api/custom_meta_fields/${id}`);
+  }
+  async createCustomMetaField(data) {
+    return this.request("POST", "/api/custom_meta_fields", { body: { custom_meta_field: data } });
+  }
+  async updateCustomMetaField(id, data) {
+    return this.request("PUT", `/api/custom_meta_fields/${id}`, { body: { custom_meta_field: data } });
+  }
+  async deleteCustomMetaField(id) {
+    await this.request("DELETE", `/api/custom_meta_fields/${id}`);
+  }
+  async exportCustomMetaField(id) {
+    return this.request("GET", `/api/custom_meta_fields/${id}/export`);
+  }
+  async importCustomMetaFields(data) {
+    return this.request("POST", "/api/custom_meta_fields/import", { body: data });
+  }
+  async getAccessRequestCustomMetaFields() {
+    return this.request("GET", "/api/custom_meta_fields/access_requests");
+  }
+  // ============================================================================
+  // Workflows
+  // ============================================================================
+  async listWorkflows(params) {
+    return this.request("GET", "/api/workflows", { params });
+  }
+  async getWorkflow(id) {
+    return this.request("GET", `/api/workflows/${id}`);
+  }
+  async createWorkflow(data) {
+    return this.request("POST", "/api/workflows", { body: { workflow: data } });
+  }
+  async updateWorkflow(id, data) {
+    return this.request("PUT", `/api/workflows/${id}`, { body: { workflow: data } });
+  }
+  async deleteWorkflow(id) {
+    await this.request("DELETE", `/api/workflows/${id}`);
+  }
+  // ============================================================================
+  // Workflow Steps
+  // ============================================================================
+  async listWorkflowSteps(params) {
+    return this.request("GET", "/api/workflow_steps", { params });
+  }
+  async getWorkflowStep(id) {
+    return this.request("GET", `/api/workflow_steps/${id}`);
+  }
+  async createWorkflowStep(data) {
+    return this.request("POST", "/api/workflow_steps", { body: { workflow_step: data } });
+  }
+  async updateWorkflowStep(id, data) {
+    return this.request("PUT", `/api/workflow_steps/${id}`, { body: { workflow_step: data } });
+  }
+  async deleteWorkflowStep(id) {
+    await this.request("DELETE", `/api/workflow_steps/${id}`);
+  }
+  async approveWorkflowStep(id) {
+    return this.request("POST", `/api/workflow_steps/${id}/approve`);
+  }
+  // ============================================================================
+  // Comments
+  // ============================================================================
+  async listComments(params) {
+    return this.request("GET", "/api/comments", { params });
+  }
+  async getComment(id) {
+    return this.request("GET", `/api/comments/${id}`);
+  }
+  async createComment(data) {
+    return this.request("POST", "/api/comments", { body: { comment: data } });
+  }
+  async updateComment(id, data) {
+    return this.request("PUT", `/api/comments/${id}`, { body: { comment: data } });
+  }
+  async deleteComment(id) {
+    await this.request("DELETE", `/api/comments/${id}`);
+  }
+  // ============================================================================
+  // Notifications
+  // ============================================================================
+  async listNotifications(params) {
+    return this.request("GET", "/api/notifications", { params });
+  }
+  async getNotificationCount() {
+    return this.request("GET", "/api/notifications/count");
+  }
+  // ============================================================================
+  // Downloads
+  // ============================================================================
+  async listDownloads(params) {
+    return this.request("GET", "/api/downloads", { params });
+  }
+  async getDownload(token) {
+    return this.request("GET", `/api/downloads/${token}`);
+  }
+  async createDownload(data) {
+    return this.request("POST", "/api/downloads", { body: { download: data } });
+  }
+  // ============================================================================
+  // Webhooks
+  // ============================================================================
+  async listWebhooks(params) {
+    return this.request("GET", "/api/webhooks", { params });
+  }
+  async getWebhook(id) {
+    return this.request("GET", `/api/webhooks/${id}`);
+  }
+  async createWebhook(data) {
+    return this.request("POST", "/api/webhooks", { body: { webhook: data } });
+  }
+  async updateWebhook(id, data) {
+    return this.request("PUT", `/api/webhooks/${id}`, { body: { webhook: data } });
+  }
+  async deleteWebhook(id) {
+    await this.request("DELETE", `/api/webhooks/${id}`);
+  }
+  async getWebhookLogs(id, params) {
+    return this.request("GET", `/api/webhooks/${id}/logs`, { params });
+  }
+  async testWebhook(data) {
+    return this.request("POST", "/api/webhooks/test", { body: data });
+  }
+  async getWebhookPayload() {
+    return this.request("GET", "/api/webhooks/payload");
+  }
+  async getWebhookResponseData() {
+    return this.request("GET", "/api/webhooks/response_data");
+  }
+  // ============================================================================
+  // User Groups
+  // ============================================================================
+  async listUserGroups(params) {
+    return this.request("GET", "/api/user_groups", { params });
+  }
+  async getUserGroup(id) {
+    return this.request("GET", `/api/user_groups/${id}`);
+  }
+  async createUserGroup(data) {
+    return this.request("POST", "/api/user_groups", { body: { user_group: data } });
+  }
+  async updateUserGroup(id, data) {
+    return this.request("PUT", `/api/user_groups/${id}`, { body: { user_group: data } });
+  }
+  async deleteUserGroup(id) {
+    await this.request("DELETE", `/api/user_groups/${id}`);
+  }
+  // ============================================================================
+  // Invites
+  // ============================================================================
+  async listInvites(params) {
+    return this.request("GET", "/api/invites", { params });
+  }
+  async getInvite(id) {
+    return this.request("GET", `/api/invites/${id}`);
+  }
+  async createInvite(data) {
+    return this.request("POST", "/api/invites", { body: { invite: data } });
+  }
+  async updateInvite(id, data) {
+    return this.request("PUT", `/api/invites/${id}`, { body: { invite: data } });
+  }
+  async deleteInvite(id) {
+    await this.request("DELETE", `/api/invites/${id}`);
+  }
+  async resendInvite(id) {
+    return this.request("POST", `/api/invites/${id}/resend`);
+  }
+  async findInvite(params) {
+    return this.request("GET", "/api/invites/find", { params });
+  }
+  async checkInviteEmail(email) {
+    return this.request("GET", "/api/invites/check_email", { params: { email } });
+  }
+  async getAvailableRoleLevels() {
+    return this.request("GET", "/api/invites/available_role_levels");
+  }
+  // ============================================================================
+  // Filter Groups
+  // ============================================================================
+  async listFilterGroups(params) {
+    return this.request("GET", "/api/filter_groups", { params });
+  }
+  async getFilterGroup(id) {
+    return this.request("GET", `/api/filter_groups/${id}`);
+  }
+  async createFilterGroup(data) {
+    return this.request("POST", "/api/filter_groups", { body: { filter_group: data } });
+  }
+  async updateFilterGroup(id, data) {
+    return this.request("PUT", `/api/filter_groups/${id}`, { body: { filter_group: data } });
+  }
+  async deleteFilterGroup(id) {
+    await this.request("DELETE", `/api/filter_groups/${id}`);
+  }
+  async updateFilterGroupVisibility(id, shared) {
+    return this.request("PUT", `/api/filter_groups/${id}/update_visibility`, { body: { shared } });
+  }
+  // ============================================================================
+  // Search Queries
+  // ============================================================================
+  async listSearchQueries(params) {
+    return this.request("GET", "/api/search_queries", { params });
+  }
+  async getSearchQuery(id) {
+    return this.request("GET", `/api/search_queries/${id}`);
+  }
+  async createSearchQuery(data) {
+    return this.request("POST", "/api/search_queries", { body: { search_query: data } });
+  }
+  async updateSearchQuery(id, data) {
+    return this.request("PUT", `/api/search_queries/${id}`, { body: { search_query: data } });
+  }
+  async deleteSearchQuery(id) {
+    await this.request("DELETE", `/api/search_queries/${id}`);
+  }
+  // ============================================================================
+  // Crop Presets
+  // ============================================================================
+  async listCropPresets(params) {
+    return this.request("GET", "/api/crop_presets", { params });
+  }
+  async getCropPreset(id) {
+    return this.request("GET", `/api/crop_presets/${id}`);
+  }
+  async createCropPreset(data) {
+    return this.request("POST", "/api/crop_presets", { body: { crop_preset: data } });
+  }
+  async updateCropPreset(id, data) {
+    return this.request("PUT", `/api/crop_presets/${id}`, { body: { crop_preset: data } });
+  }
+  async deleteCropPreset(id) {
+    await this.request("DELETE", `/api/crop_presets/${id}`);
+  }
+  async updateCropPresetPosition(id, position) {
+    return this.request("PUT", "/api/crop_presets/update_position", { body: { id, position } });
+  }
+  // ============================================================================
+  // Ingestions
+  // ============================================================================
+  async listIngestions(params) {
+    return this.request("GET", "/api/ingestions", { params });
+  }
+  // ============================================================================
+  // Meta Imports
+  // ============================================================================
+  async listMetaImports(params) {
+    return this.request("GET", "/api/meta_imports", { params });
+  }
+  async getMetaImport(id) {
+    return this.request("GET", `/api/meta_imports/${id}`);
+  }
+  async createMetaImport(data) {
+    return this.request("POST", "/api/meta_imports", { body: { meta_import: data } });
+  }
+  async getMetaImportAssets(id, params) {
+    return this.request("GET", `/api/meta_imports/${id}/assets`, { params });
+  }
+  async getMetaImportMapping(id) {
+    return this.request("GET", `/api/meta_imports/${id}/mapping`);
+  }
+  async updateMetaImportMapping(id, mapping) {
+    return this.request("PUT", `/api/meta_imports/${id}/mapping`, { body: { mapping } });
+  }
+  async startMetaImportProcess(id) {
+    return this.request("POST", `/api/meta_imports/${id}/start_process`);
+  }
+  // ============================================================================
+  // Personal Access Tokens
+  // ============================================================================
+  async listPersonalAccessTokens(params) {
+    return this.request("GET", "/api/personal_access_tokens", { params });
+  }
+  async getPersonalAccessToken(id) {
+    return this.request("GET", `/api/personal_access_tokens/${id}`);
+  }
+  async createPersonalAccessToken(data) {
+    return this.request("POST", "/api/personal_access_tokens", { body: { personal_access_token: data } });
+  }
+  async deletePersonalAccessToken(id) {
+    await this.request("DELETE", `/api/personal_access_tokens/${id}`);
+  }
+};
+// src/tools/shared.ts
+function successResult(data) {
+  return {
+    content: [
+      {
+        type: "text",
+        text: typeof data === "string" ? data : JSON.stringify(data, null, 2)
+      }
+    ]
+  };
+}
+function errorResult(message) {
+  return {
+    content: [
+      {
+        type: "text",
+        text: message
+      }
+    ],
+    isError: true
+  };
+}
+var idParam = {
+  type: ["number", "string"],
+  description: "ID of the resource"
+};
+var paginationParams = {
+  page: { type: "number", description: "Page number" },
+  per_page: { type: "number", description: "Results per page (max 100)" }
+};
+// src/tools/users.ts
+var userTools = {
+  definitions: [
+    {
+      name: "whoami",
+      description: "Get information about the currently authenticated user and organization",
+      inputSchema: { type: "object", properties: {}, required: [] }
+    },
+    {
+      name: "get_organization",
+      description: "Get details about an organization by ID",
+      inputSchema: {
+        type: "object",
+        properties: { id: idParam },
+        required: ["id"]
+      }
+    },
+    {
+      name: "list_memberships",
+      description: "List organization memberships",
+      inputSchema: { type: "object", properties: { ...paginationParams }, required: [] }
+    },
+    {
+      name: "get_membership",
+      description: "Get membership details by ID",
+      inputSchema: { type: "object", properties: { id: idParam }, required: ["id"] }
+    },
+    {
+      name: "update_membership",
+      description: "Update a membership",
+      inputSchema: {
+        type: "object",
+        properties: {
+          id: idParam,
+          role: { type: "string", enum: ["admin", "global_content", "global_library", "global_tagger", "general", "restricted"] }
+        },
+        required: ["id"]
+      }
+    }
+  ],
+  handlers: {
+    async whoami(args, { client: client2 }) {
+      return successResult(await client2.whoami());
+    },
+    async get_organization(args, { client: client2 }) {
+      return successResult(await client2.getOrganization(args.id));
+    },
+    async list_memberships(args, { client: client2 }) {
+      return successResult(await client2.listMemberships(args));
+    },
+    async get_membership(args, { client: client2 }) {
+      return successResult(await client2.getMembership(args.id));
+    },
+    async update_membership(args, { client: client2 }) {
+      const { id, ...data } = args;
+      return successResult(await client2.updateMembership(id, data));
+    }
+  }
+};
+// src/tools/assets.ts
+var assetTools = {
+  definitions: [
+    {
+      name: "search_assets",
+      description: `Search for assets using filters and advanced query operators.
+ADVANCED SEARCH QUERY SYNTAX (for the 'q' parameter):
+- Basic: Just type a term to search all fields (e.g., "dog")
+- Exclude: Use NOT or minus to exclude (e.g., "NOT dog" or "-dog")
+- Combine: Use AND, OR, NOT (e.g., "dog AND cat", "dog OR cat", "dog NOT cat")
+- Field search: Use field:value syntax (e.g., "tag_text:nature", "filename.keyword:IMG_1234.jpg")
+- Wildcards: Use * (zero or more chars) or ? (single char) (e.g., "tag_text:part*", "tag_text:?artial")
+- Existence: Use field:** to find assets with any value, NOT field:** for empty (e.g., "NOT tag_text:**" finds untagged assets)
+- Complex: Use parentheses for grouping (e.g., "(dog OR cat) AND ext:jpg")
+COMMON SEARCH FIELDS:
+- tag_text: Keywords/tags
+- filename.keyword: Exact filename
+- description: Asset description
+- title: Asset title
+- ext: File extension
+- creator_text: Creator/photographer name
+- copyright: Copyright text
+- city, state, country: Location fields`,
+      inputSchema: {
+        type: "object",
+        properties: {
+          q: { type: "string", description: "Search query with optional advanced operators (AND, OR, NOT, field:value, wildcards)" },
+          ...paginationParams,
+          ids: { type: "array", items: { type: "number" }, description: "Filter by specific asset IDs" },
+          guids: { type: "array", items: { type: "string" }, description: "Filter by specific asset GUIDs" },
+          tags: { type: "array", items: { type: "string" }, description: "Filter by tags" },
+          collection_id: { type: "number", description: "Filter by collection ID" },
+          storage_folder_id: { type: "number", description: "Filter by storage folder ID" },
+          lightbox_id: { type: "number", description: "Filter by lightbox ID" },
+          exts: { type: "array", items: { type: "string" }, description: "Filter by file extensions" },
+          rating: { type: "array", items: { type: "number" }, description: "Filter by rating range [min, max]" },
+          aspect: { type: "string", enum: ["square", "portrait", "landscape", "panorama"] },
+          has_people: { type: "string", enum: ["yes", "no", "untagged"] },
+          has_alt_text: { type: "string", enum: ["yes", "no"] },
+          gps: { type: "boolean", description: "Filter for assets with GPS data" },
+          captured_at: { type: "array", items: { type: "string" }, description: "Date range [start, end] in ISO 8601" },
+          created_at: { type: "array", items: { type: "string" }, description: "Date range [start, end] in ISO 8601" },
+          include_totals: { type: "boolean", description: "Include aggregate counts" },
+          include_renditions: { type: "boolean", description: "Include available sizes/formats" },
+          include_meta: { type: "boolean", description: "Include full EXIF/IPTC metadata" }
+        },
+        required: []
+      }
+    },
+    {
+      name: "get_asset",
+      description: "Get detailed information about a specific asset",
+      inputSchema: {
+        type: "object",
+        properties: {
+          id: idParam,
+          include_renditions: { type: "boolean" },
+          include_meta: { type: "boolean" }
+        },
+        required: ["id"]
+      }
+    },
+    {
+      name: "update_asset",
+      description: "Update asset metadata",
+      inputSchema: {
+        type: "object",
+        properties: {
+          id: idParam,
+          title: { type: "string" },
+          description: { type: "string" },
+          alt_text: { type: "string" },
+          caption: { type: "string" },
+          credit: { type: "string" },
+          copyright: { type: "string" },
+          rating: { type: "number", minimum: 0, maximum: 5 },
+          headline: { type: "string" },
+          city: { type: "string" },
+          state: { type: "string" },
+          country: { type: "string" },
+          notes: { type: "string" }
+        },
+        required: ["id"]
+      }
+    },
+    {
+      name: "delete_asset",
+      description: "Delete (trash) an asset",
+      inputSchema: { type: "object", properties: { id: idParam }, required: ["id"] }
+    },
+    {
+      name: "add_tags_to_asset",
+      description: "Add tags to an asset",
+      inputSchema: {
+        type: "object",
+        properties: {
+          id: idParam,
+          tags: { type: "array", items: { type: "string" }, description: "Tags to add" }
+        },
+        required: ["id", "tags"]
+      }
+    },
+    {
+      name: "get_asset_download",
+      description: "Get a download URL for an asset",
+      inputSchema: {
+        type: "object",
+        properties: {
+          id: idParam,
+          rendition: { type: "string", description: "Specific rendition (original, full, medium, small)" }
+        },
+        required: ["id"]
+      }
+    },
+    {
+      name: "get_asset_auto_tags",
+      description: "Get AI-generated auto tags for an asset",
+      inputSchema: { type: "object", properties: { id: idParam }, required: ["id"] }
+    },
+    {
+      name: "get_asset_face_taggings",
+      description: "Get face taggings for an asset",
+      inputSchema: { type: "object", properties: { id: idParam }, required: ["id"] }
+    },
+    {
+      name: "get_asset_versions",
+      description: "Get version history for an asset",
+      inputSchema: { type: "object", properties: { asset_id: idParam }, required: ["asset_id"] }
+    },
+    {
+      name: "revert_asset",
+      description: "Revert an asset to a previous version",
+      inputSchema: {
+        type: "object",
+        properties: {
+          id: idParam,
+          version_number: { type: "number", description: "Version number to revert to" }
+        },
+        required: ["id", "version_number"]
+      }
+    },
+    {
+      name: "get_asset_counts",
+      description: "Get asset counts with optional filters",
+      inputSchema: {
+        type: "object",
+        properties: {
+          collection_id: { type: "number" },
+          storage_folder_id: { type: "number" },
+          tags: { type: "array", items: { type: "string" } }
+        },
+        required: []
+      }
+    },
+    {
+      name: "get_trashed_assets",
+      description: "Get trashed assets",
+      inputSchema: { type: "object", properties: { ...paginationParams }, required: [] }
+    },
+    {
+      name: "get_popular_assets",
+      description: "Get popular assets",
+      inputSchema: { type: "object", properties: { ...paginationParams }, required: [] }
+    }
+  ],
+  handlers: {
+    async search_assets(args, { client: client2 }) {
+      return successResult(await client2.searchAssets(args));
+    },
+    async get_asset(args, { client: client2 }) {
+      return successResult(await client2.getAsset(args.id, {
+        include_renditions: args.include_renditions,
+        include_meta: args.include_meta
+      }));
+    },
+    async update_asset(args, { client: client2 }) {
+      const { id, ...data } = args;
+      return successResult(await client2.updateAsset(id, data));
+    },
+    async delete_asset(args, { client: client2 }) {
+      await client2.deleteAsset(args.id);
+      return successResult({ success: true });
+    },
+    async add_tags_to_asset(args, { client: client2 }) {
+      return successResult(await client2.addTagsToAsset(args.id, args.tags));
+    },
+    async get_asset_download(args, { client: client2 }) {
+      return successResult(await client2.getAssetDownload(args.id, args.rendition));
+    },
+    async get_asset_auto_tags(args, { client: client2 }) {
+      return successResult(await client2.getAssetAutoTags(args.id));
+    },
+    async get_asset_face_taggings(args, { client: client2 }) {
+      return successResult(await client2.getAssetFaceTaggings(args.id));
+    },
+    async get_asset_versions(args, { client: client2 }) {
+      return successResult(await client2.getAssetDataVersions(args.asset_id));
+    },
+    async revert_asset(args, { client: client2 }) {
+      return successResult(await client2.revertAsset(args.id, args.version_number));
+    },
+    async get_asset_counts(args, { client: client2 }) {
+      return successResult(await client2.getAssetCounts(args));
+    },
+    async get_trashed_assets(args, { client: client2 }) {
+      return successResult(await client2.getTrashedAssets(args));
+    },
+    async get_popular_assets(args, { client: client2 }) {
+      return successResult(await client2.getPopularAssets(args));
+    }
+  }
+};
+// src/tools/groups.ts
+var groupTools = {
+  definitions: [
+    // Collections
+    {
+      name: "list_collections",
+      description: "List collections in the organization",
+      inputSchema: {
+        type: "object",
+        properties: { ...paginationParams, parent_id: { type: "number" } },
+        required: []
+      }
+    },
+    {
+      name: "get_collection",
+      description: "Get collection details",
+      inputSchema: { type: "object", properties: { id: idParam }, required: ["id"] }
+    },
+    {
+      name: "create_collection",
+      description: "Create a new collection",
+      inputSchema: {
+        type: "object",
+        properties: {
+          name: { type: "string" },
+          description: { type: "string" },
+          parent_id: { type: "number" }
+        },
+        required: ["name"]
+      }
+    },
+    {
+      name: "update_collection",
+      description: "Update a collection",
+      inputSchema: {
+        type: "object",
+        properties: {
+          id: idParam,
+          name: { type: "string" },
+          description: { type: "string" }
+        },
+        required: ["id"]
+      }
+    },
+    {
+      name: "delete_collection",
+      description: "Delete a collection",
+      inputSchema: { type: "object", properties: { id: idParam }, required: ["id"] }
+    },
+    {
+      name: "add_asset_to_collection",
+      description: "Add an asset to a collection",
+      inputSchema: {
+        type: "object",
+        properties: { collection_id: idParam, asset_id: idParam },
+        required: ["collection_id", "asset_id"]
+      }
+    },
+    {
+      name: "get_collections_tree",
+      description: "Get collections hierarchy as a tree",
+      inputSchema: { type: "object", properties: {}, required: [] }
+    },
+    // Lightboxes
+    {
+      name: "list_lightboxes",
+      description: "List lightboxes in the organization",
+      inputSchema: {
+        type: "object",
+        properties: { ...paginationParams, parent_id: { type: "number" } },
+        required: []
+      }
+    },
+    {
+      name: "get_lightbox",
+      description: "Get lightbox details",
+      inputSchema: { type: "object", properties: { id: idParam }, required: ["id"] }
+    },
+    {
+      name: "create_lightbox",
+      description: "Create a new lightbox",
+      inputSchema: {
+        type: "object",
+        properties: {
+          name: { type: "string" },
+          description: { type: "string" },
+          parent_id: { type: "number" }
+        },
+        required: ["name"]
+      }
+    },
+    {
+      name: "update_lightbox",
+      description: "Update a lightbox",
+      inputSchema: {
+        type: "object",
+        properties: { id: idParam, name: { type: "string" }, description: { type: "string" } },
+        required: ["id"]
+      }
+    },
+    {
+      name: "delete_lightbox",
+      description: "Delete a lightbox",
+      inputSchema: { type: "object", properties: { id: idParam }, required: ["id"] }
+    },
+    {
+      name: "add_asset_to_lightbox",
+      description: "Add an asset to a lightbox",
+      inputSchema: {
+        type: "object",
+        properties: { lightbox_id: idParam, asset_id: idParam },
+        required: ["lightbox_id", "asset_id"]
+      }
+    },
+    {
+      name: "get_lightboxes_tree",
+      description: "Get lightboxes hierarchy as a tree",
+      inputSchema: { type: "object", properties: {}, required: [] }
+    },
+    // Storage Folders
+    {
+      name: "list_storage_folders",
+      description: "List storage folders",
+      inputSchema: {
+        type: "object",
+        properties: { ...paginationParams, parent_id: { type: "number" } },
+        required: []
+      }
+    },
+    {
+      name: "get_storage_folder",
+      description: "Get storage folder details",
+      inputSchema: { type: "object", properties: { id: idParam }, required: ["id"] }
+    },
+    {
+      name: "create_storage_folder",
+      description: "Create a new storage folder",
+      inputSchema: {
+        type: "object",
+        properties: { name: { type: "string" }, description: { type: "string" }, parent_id: { type: "number" } },
+        required: ["name"]
+      }
+    },
+    {
+      name: "get_storage_folders_tree",
+      description: "Get storage folders hierarchy as a tree",
+      inputSchema: { type: "object", properties: {}, required: [] }
+    }
+  ],
+  handlers: {
+    // Collections
+    async list_collections(args, { client: client2 }) {
+      return successResult(await client2.listCollections(args));
+    },
+    async get_collection(args, { client: client2 }) {
+      return successResult(await client2.getCollection(args.id));
+    },
+    async create_collection(args, { client: client2 }) {
+      return successResult(await client2.createCollection(args));
+    },
+    async update_collection(args, { client: client2 }) {
+      const { id, ...data } = args;
+      return successResult(await client2.updateCollection(id, data));
+    },
+    async delete_collection(args, { client: client2 }) {
+      await client2.deleteCollection(args.id);
+      return successResult({ success: true });
+    },
+    async add_asset_to_collection(args, { client: client2 }) {
+      await client2.addAssetToCollection(args.collection_id, args.asset_id);
+      return successResult({ success: true });
+    },
+    async get_collections_tree(_args, { client: client2 }) {
+      return successResult(await client2.getCollectionsTree());
+    },
+    // Lightboxes
+    async list_lightboxes(args, { client: client2 }) {
+      return successResult(await client2.listLightboxes(args));
+    },
+    async get_lightbox(args, { client: client2 }) {
+      return successResult(await client2.getLightbox(args.id));
+    },
+    async create_lightbox(args, { client: client2 }) {
+      return successResult(await client2.createLightbox(args));
+    },
+    async update_lightbox(args, { client: client2 }) {
+      const { id, ...data } = args;
+      return successResult(await client2.updateLightbox(id, data));
+    },
+    async delete_lightbox(args, { client: client2 }) {
+      await client2.deleteLightbox(args.id);
+      return successResult({ success: true });
+    },
+    async add_asset_to_lightbox(args, { client: client2 }) {
+      await client2.addAssetToLightbox(args.lightbox_id, args.asset_id);
+      return successResult({ success: true });
+    },
+    async get_lightboxes_tree(_args, { client: client2 }) {
+      return successResult(await client2.getLightboxesTree());
+    },
+    // Storage Folders
+    async list_storage_folders(args, { client: client2 }) {
+      return successResult(await client2.listStorageFolders(args));
+    },
+    async get_storage_folder(args, { client: client2 }) {
+      return successResult(await client2.getStorageFolder(args.id));
+    },
+    async create_storage_folder(args, { client: client2 }) {
+      return successResult(await client2.createStorageFolder(args));
+    },
+    async get_storage_folders_tree(_args, { client: client2 }) {
+      return successResult(await client2.getStorageFoldersTree());
+    }
+  }
+};
+// src/tools/tags.ts
+var tagTools = {
+  definitions: [
+    // Tags
+    {
+      name: "list_tags",
+      description: "List tags in the organization",
+      inputSchema: {
+        type: "object",
+        properties: { ...paginationParams, q: { type: "string", description: "Search query" } },
+        required: []
+      }
+    },
+    {
+      name: "get_tag",
+      description: "Get tag details",
+      inputSchema: { type: "object", properties: { id: idParam }, required: ["id"] }
+    },
+    {
+      name: "create_tag",
+      description: "Create a new tag",
+      inputSchema: {
+        type: "object",
+        properties: { name: { type: "string" }, parent_id: { type: "number" } },
+        required: ["name"]
+      }
+    },
+    {
+      name: "update_tag",
+      description: "Update a tag",
+      inputSchema: {
+        type: "object",
+        properties: { id: idParam, name: { type: "string" } },
+        required: ["id"]
+      }
+    },
+    {
+      name: "delete_tag",
+      description: "Delete a tag",
+      inputSchema: { type: "object", properties: { id: idParam }, required: ["id"] }
+    },
+    {
+      name: "merge_tags",
+      description: "Merge one tag into another",
+      inputSchema: {
+        type: "object",
+        properties: { id: idParam, target_tag_id: { type: "number" } },
+        required: ["id", "target_tag_id"]
+      }
+    },
+    // Taggings
+    {
+      name: "get_tagging",
+      description: "Get details of a specific tagging (tag-to-asset relationship)",
+      inputSchema: { type: "object", properties: { id: idParam }, required: ["id"] }
+    },
+    // Auto Tags
+    {
+      name: "list_auto_tags",
+      description: "List AI-generated auto tags",
+      inputSchema: {
+        type: "object",
+        properties: { ...paginationParams, q: { type: "string" } },
+        required: []
+      }
+    },
+    // Taxonomies
+    {
+      name: "list_taxonomies",
+      description: "List taxonomies (controlled vocabularies)",
+      inputSchema: { type: "object", properties: { ...paginationParams }, required: [] }
+    },
+    {
+      name: "get_taxonomy",
+      description: "Get taxonomy details",
+      inputSchema: { type: "object", properties: { id: idParam }, required: ["id"] }
+    },
+    {
+      name: "create_taxonomy",
+      description: "Create a new taxonomy",
+      inputSchema: {
+        type: "object",
+        properties: { name: { type: "string" }, description: { type: "string" } },
+        required: ["name"]
+      }
+    },
+    {
+      name: "list_taxonomy_tags",
+      description: "List tags within a taxonomy",
+      inputSchema: {
+        type: "object",
+        properties: { taxonomy_id: idParam, ...paginationParams, parent_id: { type: "number" } },
+        required: ["taxonomy_id"]
+      }
+    },
+    {
+      name: "create_taxonomy_tag",
+      description: "Create a tag within a taxonomy",
+      inputSchema: {
+        type: "object",
+        properties: { taxonomy_id: idParam, name: { type: "string" }, parent_id: { type: "number" } },
+        required: ["taxonomy_id", "name"]
+      }
+    },
+    // Creator Tags
+    {
+      name: "list_creator_tags",
+      description: "List creator/photographer tags",
+      inputSchema: {
+        type: "object",
+        properties: { ...paginationParams, q: { type: "string" } },
+        required: []
+      }
+    },
+    {
+      name: "create_creator_tag",
+      description: "Create a new creator tag",
+      inputSchema: {
+        type: "object",
+        properties: { name: { type: "string" } },
+        required: ["name"]
+      }
+    }
+  ],
+  handlers: {
+    // Tags
+    async list_tags(args, { client: client2 }) {
+      return successResult(await client2.listTags(args));
+    },
+    async get_tag(args, { client: client2 }) {
+      return successResult(await client2.getTag(args.id));
+    },
+    async create_tag(args, { client: client2 }) {
+      return successResult(await client2.createTag(args));
+    },
+    async update_tag(args, { client: client2 }) {
+      const { id, ...data } = args;
+      return successResult(await client2.updateTag(id, data));
+    },
+    async delete_tag(args, { client: client2 }) {
+      await client2.deleteTag(args.id);
+      return successResult({ success: true });
+    },
+    async merge_tags(args, { client: client2 }) {
+      await client2.mergeTagInto(args.id, args.target_tag_id);
+      return successResult({ success: true });
+    },
+    // Taggings
+    async get_tagging(args, { client: client2 }) {
+      return successResult(await client2.getTagging(args.id));
+    },
+    // Auto Tags
+    async list_auto_tags(args, { client: client2 }) {
+      return successResult(await client2.listAutoTags(args));
+    },
+    // Taxonomies
+    async list_taxonomies(args, { client: client2 }) {
+      return successResult(await client2.listTaxonomies(args));
+    },
+    async get_taxonomy(args, { client: client2 }) {
+      return successResult(await client2.getTaxonomy(args.id));
+    },
+    async create_taxonomy(args, { client: client2 }) {
+      return successResult(await client2.createTaxonomy(args));
+    },
+    async list_taxonomy_tags(args, { client: client2 }) {
+      return successResult(await client2.listTaxonomyTags(args.taxonomy_id, args));
+    },
+    async create_taxonomy_tag(args, { client: client2 }) {
+      return successResult(await client2.createTaxonomyTag(args.taxonomy_id, args));
+    },
+    // Creator Tags
+    async list_creator_tags(args, { client: client2 }) {
+      return successResult(await client2.listCreatorTags(args));
+    },
+    async create_creator_tag(args, { client: client2 }) {
+      return successResult(await client2.createCreatorTag(args));
+    }
+  }
+};
+// src/tools/rights.ts
+var rightsTools = {
+  definitions: [
+    {
+      name: "list_rights_packages",
+      description: "List rights packages for managing asset usage rights",
+      inputSchema: { type: "object", properties: { ...paginationParams }, required: [] }
+    },
+    {
+      name: "get_rights_package",
+      description: "Get rights package details",
+      inputSchema: { type: "object", properties: { id: idParam }, required: ["id"] }
+    },
+    {
+      name: "create_rights_package",
+      description: "Create a new rights package",
+      inputSchema: {
+        type: "object",
+        properties: {
+          name: { type: "string" },
+          rights_class: { type: "string", enum: ["owned", "unlimited", "some", "library", "none"] },
+          description: { type: "string" },
+          expires: { type: "boolean" },
+          expires_at: { type: "string" }
+        },
+        required: ["name", "rights_class"]
+      }
+    }
+  ],
+  handlers: {
+    async list_rights_packages(args, { client: client2 }) {
+      return successResult(await client2.listRightsPackages(args));
+    },
+    async get_rights_package(args, { client: client2 }) {
+      return successResult(await client2.getRightsPackage(args.id));
+    },
+    async create_rights_package(args, { client: client2 }) {
+      return successResult(await client2.createRightsPackage(args));
+    }
+  }
+};
+// src/tools/sharing.ts
+var sharingTools = {
+  definitions: [
+    // Share Links
+    {
+      name: "list_share_links",
+      description: "List share links",
+      inputSchema: { type: "object", properties: { ...paginationParams }, required: [] }
+    },
+    {
+      name: "get_share_link",
+      description: "Get share link details",
+      inputSchema: { type: "object", properties: { id: idParam }, required: ["id"] }
+    },
+    {
+      name: "create_share_link",
+      description: "Create a share link for assets, collection, or lightbox",
+      inputSchema: {
+        type: "object",
+        properties: {
+          asset_ids: { type: "array", items: { type: "number" } },
+          collection_id: { type: "number" },
+          lightbox_id: { type: "number" },
+          name: { type: "string" },
+          password: { type: "string" },
+          expires_at: { type: "string" }
+        },
+        required: []
+      }
+    },
+    {
+      name: "delete_share_link",
+      description: "Delete a share link",
+      inputSchema: { type: "object", properties: { id: idParam }, required: ["id"] }
+    },
+    // Access Requests
+    {
+      name: "list_access_requests",
+      description: "List access requests and grants",
+      inputSchema: {
+        type: "object",
+        properties: {
+          ...paginationParams,
+          type: { type: "string", enum: ["grant", "request"] },
+          aasm_state: { type: "string", enum: ["pending", "submitted", "finalized"] }
+        },
+        required: []
+      }
+    },
+    {
+      name: "get_access_request",
+      description: "Get access request details",
+      inputSchema: { type: "object", properties: { id: idParam }, required: ["id"] }
+    },
+    {
+      name: "submit_access_request",
+      description: "Submit an access request",
+      inputSchema: { type: "object", properties: { id: idParam }, required: ["id"] }
+    }
+  ],
+  handlers: {
+    // Share Links
+    async list_share_links(args, { client: client2 }) {
+      return successResult(await client2.listShareLinks(args));
+    },
+    async get_share_link(args, { client: client2 }) {
+      return successResult(await client2.getShareLink(args.id));
+    },
+    async create_share_link(args, { client: client2 }) {
+      return successResult(await client2.createShareLink(args));
+    },
+    async delete_share_link(args, { client: client2 }) {
+      await client2.deleteShareLink(args.id);
+      return successResult({ success: true });
+    },
+    // Access Requests
+    async list_access_requests(args, { client: client2 }) {
+      return successResult(await client2.listAccessRequests(args));
+    },
+    async get_access_request(args, { client: client2 }) {
+      return successResult(await client2.getAccessRequest(args.id));
+    },
+    async submit_access_request(args, { client: client2 }) {
+      return successResult(await client2.submitAccessRequest(args.id));
+    }
+  }
+};
+// src/tools/jobs.ts
+var jobTools = {
+  definitions: [
+    // Bulk Jobs
+    {
+      name: "list_bulk_jobs",
+      description: "List bulk jobs",
+      inputSchema: { type: "object", properties: { ...paginationParams }, required: [] }
+    },
+    {
+      name: "get_bulk_job",
+      description: "Get bulk job details and status",
+      inputSchema: { type: "object", properties: { id: idParam }, required: ["id"] }
+    },
+    {
+      name: "create_bulk_job",
+      description: "Create a bulk job for batch operations on assets",
+      inputSchema: {
+        type: "object",
+        properties: {
+          asset_ids: { type: "array", items: { type: "number" }, description: "Asset IDs to process" },
+          action: { type: "string", description: "Bulk action (add_tags, remove_tags, add_to_collection, etc.)" },
+          params: { type: "object", description: "Action parameters" }
+        },
+        required: ["asset_ids", "action"]
+      }
+    },
+    {
+      name: "cancel_bulk_job",
+      description: "Cancel a running bulk job",
+      inputSchema: { type: "object", properties: { id: idParam }, required: ["id"] }
+    },
+    {
+      name: "get_bulk_job_queue_position",
+      description: "Get queue position for a bulk job",
+      inputSchema: { type: "object", properties: { id: idParam }, required: ["id"] }
+    },
+    // Meta Imports
+    {
+      name: "list_meta_imports",
+      description: "List metadata import jobs",
+      inputSchema: { type: "object", properties: { ...paginationParams }, required: [] }
+    },
+    {
+      name: "get_meta_import",
+      description: "Get metadata import job details",
+      inputSchema: { type: "object", properties: { id: idParam }, required: ["id"] }
+    },
+    // Ingestions
+    {
+      name: "list_ingestions",
+      description: "List ingestion jobs",
+      inputSchema: { type: "object", properties: { ...paginationParams }, required: [] }
+    }
+  ],
+  handlers: {
+    // Bulk Jobs
+    async list_bulk_jobs(args, { client: client2 }) {
+      return successResult(await client2.listBulkJobs(args));
+    },
+    async get_bulk_job(args, { client: client2 }) {
+      return successResult(await client2.getBulkJob(args.id));
+    },
+    async create_bulk_job(args, { client: client2 }) {
+      return successResult(await client2.createBulkJob(args));
+    },
+    async cancel_bulk_job(args, { client: client2 }) {
+      return successResult(await client2.cancelBulkJob(args.id));
+    },
+    async get_bulk_job_queue_position(args, { client: client2 }) {
+      return successResult(await client2.getBulkJobQueuePosition(args.id));
+    },
+    // Meta Imports
+    async list_meta_imports(args, { client: client2 }) {
+      return successResult(await client2.listMetaImports(args));
+    },
+    async get_meta_import(args, { client: client2 }) {
+      return successResult(await client2.getMetaImport(args.id));
+    },
+    // Ingestions
+    async list_ingestions(args, { client: client2 }) {
+      return successResult(await client2.listIngestions(args));
+    }
+  }
+};
+// src/tools/meta.ts
+var metaTools = {
+  definitions: [
+    {
+      name: "list_custom_meta_fields",
+      description: "List custom metadata fields",
+      inputSchema: { type: "object", properties: { ...paginationParams }, required: [] }
+    },
+    {
+      name: "get_custom_meta_field",
+      description: "Get custom meta field details",
+      inputSchema: { type: "object", properties: { id: idParam }, required: ["id"] }
+    },
+    {
+      name: "create_custom_meta_field",
+      description: "Create a custom metadata field",
+      inputSchema: {
+        type: "object",
+        properties: {
+          name: { type: "string" },
+          field_type: { type: "string", enum: ["text", "textarea", "select", "multiselect", "date", "number", "boolean"] },
+          description: { type: "string" },
+          required: { type: "boolean" },
+          searchable: { type: "boolean" },
+          filterable: { type: "boolean" },
+          options: { type: "array", items: { type: "string" } },
+          enable_ai: { type: "boolean" },
+          ai_prompt: { type: "string" }
+        },
+        required: ["name", "field_type"]
+      }
+    }
+  ],
+  handlers: {
+    async list_custom_meta_fields(args, { client: client2 }) {
+      return successResult(await client2.listCustomMetaFields(args));
+    },
+    async get_custom_meta_field(args, { client: client2 }) {
+      return successResult(await client2.getCustomMetaField(args.id));
+    },
+    async create_custom_meta_field(args, { client: client2 }) {
+      return successResult(await client2.createCustomMetaField(args));
+    }
+  }
+};
+// src/tools/workflows.ts
+var workflowTools = {
+  definitions: [
+    {
+      name: "list_workflows",
+      description: "List workflows",
+      inputSchema: { type: "object", properties: { ...paginationParams }, required: [] }
+    },
+    {
+      name: "get_workflow",
+      description: "Get workflow details",
+      inputSchema: { type: "object", properties: { id: idParam }, required: ["id"] }
+    },
+    {
+      name: "approve_workflow_step",
+      description: "Approve a workflow step",
+      inputSchema: { type: "object", properties: { id: idParam }, required: ["id"] }
+    }
+  ],
+  handlers: {
+    async list_workflows(args, { client: client2 }) {
+      return successResult(await client2.listWorkflows(args));
+    },
+    async get_workflow(args, { client: client2 }) {
+      return successResult(await client2.getWorkflow(args.id));
+    },
+    async approve_workflow_step(args, { client: client2 }) {
+      return successResult(await client2.approveWorkflowStep(args.id));
+    }
+  }
+};
+// src/tools/social.ts
+var socialTools = {
+  definitions: [
+    // Comments
+    {
+      name: "list_comments",
+      description: "List comments on a resource",
+      inputSchema: {
+        type: "object",
+        properties: {
+          commentable_type: { type: "string", enum: ["Asset", "Collection", "Lightbox"] },
+          commentable_id: { type: "number" },
+          ...paginationParams
+        },
+        required: ["commentable_type", "commentable_id"]
+      }
+    },
+    {
+      name: "create_comment",
+      description: "Create a comment",
+      inputSchema: {
+        type: "object",
+        properties: {
+          body: { type: "string" },
+          commentable_type: { type: "string", enum: ["Asset", "Collection", "Lightbox"] },
+          commentable_id: { type: "number" },
+          parent_id: { type: "number" }
+        },
+        required: ["body", "commentable_type", "commentable_id"]
+      }
+    },
+    {
+      name: "delete_comment",
+      description: "Delete a comment",
+      inputSchema: { type: "object", properties: { id: idParam }, required: ["id"] }
+    },
+    // Notifications
+    {
+      name: "list_notifications",
+      description: "List notifications",
+      inputSchema: { type: "object", properties: { ...paginationParams }, required: [] }
+    },
+    {
+      name: "get_notification_count",
+      description: "Get unread notification count",
+      inputSchema: { type: "object", properties: {}, required: [] }
+    }
+  ],
+  handlers: {
+    // Comments
+    async list_comments(args, { client: client2 }) {
+      return successResult(await client2.listComments(args));
+    },
+    async create_comment(args, { client: client2 }) {
+      return successResult(await client2.createComment(args));
+    },
+    async delete_comment(args, { client: client2 }) {
+      await client2.deleteComment(args.id);
+      return successResult({ success: true });
+    },
+    // Notifications
+    async list_notifications(args, { client: client2 }) {
+      return successResult(await client2.listNotifications(args));
+    },
+    async get_notification_count(_args, { client: client2 }) {
+      return successResult(await client2.getNotificationCount());
+    }
+  }
+};
+// src/tools/downloads.ts
+var downloadTools = {
+  definitions: [
+    {
+      name: "create_download",
+      description: "Create a batch download for multiple assets",
+      inputSchema: {
+        type: "object",
+        properties: {
+          asset_ids: { type: "array", items: { type: "number" } },
+          rendition: { type: "string" }
+        },
+        required: ["asset_ids"]
+      }
+    },
+    {
+      name: "get_download",
+      description: "Get download status and URL",
+      inputSchema: { type: "object", properties: { token: { type: "string" } }, required: ["token"] }
+    }
+  ],
+  handlers: {
+    async create_download(args, { client: client2 }) {
+      return successResult(await client2.createDownload(args));
+    },
+    async get_download(args, { client: client2 }) {
+      return successResult(await client2.getDownload(args.token));
+    }
+  }
+};
+// src/tools/webhooks.ts
+var webhookTools = {
+  definitions: [
+    {
+      name: "list_webhooks",
+      description: "List webhooks",
+      inputSchema: { type: "object", properties: { ...paginationParams }, required: [] }
+    },
+    {
+      name: "get_webhook",
+      description: "Get webhook details",
+      inputSchema: { type: "object", properties: { id: idParam }, required: ["id"] }
+    },
+    {
+      name: "create_webhook",
+      description: "Create a webhook",
+      inputSchema: {
+        type: "object",
+        properties: {
+          name: { type: "string" },
+          url: { type: "string" },
+          events: { type: "array", items: { type: "string" } }
+        },
+        required: ["name", "url", "events"]
+      }
+    },
+    {
+      name: "delete_webhook",
+      description: "Delete a webhook",
+      inputSchema: { type: "object", properties: { id: idParam }, required: ["id"] }
+    },
+    {
+      name: "get_webhook_logs",
+      description: "Get webhook delivery logs",
+      inputSchema: { type: "object", properties: { id: idParam, ...paginationParams }, required: ["id"] }
+    }
+  ],
+  handlers: {
+    async list_webhooks(args, { client: client2 }) {
+      return successResult(await client2.listWebhooks(args));
+    },
+    async get_webhook(args, { client: client2 }) {
+      return successResult(await client2.getWebhook(args.id));
+    },
+    async create_webhook(args, { client: client2 }) {
+      return successResult(await client2.createWebhook(args));
+    },
+    async delete_webhook(args, { client: client2 }) {
+      await client2.deleteWebhook(args.id);
+      return successResult({ success: true });
+    },
+    async get_webhook_logs(args, { client: client2 }) {
+      return successResult(await client2.getWebhookLogs(args.id, args));
+    }
+  }
+};
+// src/tools/admin.ts
+var adminTools = {
+  definitions: [
+    // User Groups
+    {
+      name: "list_user_groups",
+      description: "List user groups",
+      inputSchema: { type: "object", properties: { ...paginationParams }, required: [] }
+    },
+    {
+      name: "create_user_group",
+      description: "Create a user group",
+      inputSchema: {
+        type: "object",
+        properties: { name: { type: "string" }, description: { type: "string" } },
+        required: ["name"]
+      }
+    },
+    // Invites
+    {
+      name: "list_invites",
+      description: "List pending invites",
+      inputSchema: { type: "object", properties: { ...paginationParams }, required: [] }
+    },
+    {
+      name: "create_invite",
+      description: "Invite a user to the organization",
+      inputSchema: {
+        type: "object",
+        properties: {
+          email: { type: "string" },
+          role: { type: "string", enum: ["admin", "global_content", "global_library", "global_tagger", "general", "restricted"] }
+        },
+        required: ["email", "role"]
+      }
+    },
+    {
+      name: "update_invite",
+      description: "Update an invite (change email or role)",
+      inputSchema: {
+        type: "object",
+        properties: {
+          id: idParam,
+          email: { type: "string" },
+          role: { type: "string", enum: ["admin", "global_content", "global_library", "global_tagger", "general", "restricted"] }
+        },
+        required: ["id"]
+      }
+    },
+    {
+      name: "resend_invite",
+      description: "Resend an invite email",
+      inputSchema: { type: "object", properties: { id: idParam }, required: ["id"] }
+    },
+    // Filter Groups
+    {
+      name: "list_filter_groups",
+      description: "List saved filter groups",
+      inputSchema: { type: "object", properties: { ...paginationParams }, required: [] }
+    },
+    {
+      name: "create_filter_group",
+      description: "Save a filter group",
+      inputSchema: {
+        type: "object",
+        properties: {
+          name: { type: "string" },
+          filters: { type: "object", description: "Filter parameters to save" }
+        },
+        required: ["name", "filters"]
+      }
+    },
+    // Search Queries
+    {
+      name: "list_search_queries",
+      description: "List saved search queries",
+      inputSchema: { type: "object", properties: { ...paginationParams }, required: [] }
+    },
+    {
+      name: "create_search_query",
+      description: "Save a search query",
+      inputSchema: {
+        type: "object",
+        properties: {
+          name: { type: "string" },
+          query: { type: "string" },
+          filters: { type: "object" }
+        },
+        required: ["name", "query"]
+      }
+    },
+    // Crop Presets
+    {
+      name: "list_crop_presets",
+      description: "List crop presets",
+      inputSchema: { type: "object", properties: { ...paginationParams }, required: [] }
+    },
+    {
+      name: "create_crop_preset",
+      description: "Create a crop preset",
+      inputSchema: {
+        type: "object",
+        properties: {
+          name: { type: "string" },
+          width: { type: "number" },
+          height: { type: "number" }
+        },
+        required: ["name", "width", "height"]
+      }
+    },
+    // Uploads
+    {
+      name: "can_upload",
+      description: "Check if uploads are allowed (storage quota)",
+      inputSchema: { type: "object", properties: {}, required: [] }
+    },
+    {
+      name: "list_uploads",
+      description: "List upload sessions",
+      inputSchema: { type: "object", properties: { ...paginationParams }, required: [] }
+    },
+    {
+      name: "add_assets_to_upload",
+      description: "Add assets to an upload session",
+      inputSchema: {
+        type: "object",
+        properties: {
+          guid: { type: "string", description: "Upload session GUID" },
+          asset_ids: { type: "array", items: { type: "number" }, description: "Asset IDs to add" }
+        },
+        required: ["guid", "asset_ids"]
+      }
+    },
+    // Contributions
+    {
+      name: "list_contributions",
+      description: "List contribution portals",
+      inputSchema: { type: "object", properties: { ...paginationParams }, required: [] }
+    },
+    {
+      name: "get_contribution",
+      description: "Get contribution details",
+      inputSchema: { type: "object", properties: { id: idParam }, required: ["id"] }
+    },
+    // Personal Access Tokens
+    {
+      name: "list_personal_access_tokens",
+      description: "List personal access tokens",
+      inputSchema: { type: "object", properties: { ...paginationParams }, required: [] }
+    },
+    {
+      name: "create_personal_access_token",
+      description: "Create a personal access token",
+      inputSchema: {
+        type: "object",
+        properties: {
+          name: { type: "string" },
+          scopes: { type: "array", items: { type: "string" } }
+        },
+        required: ["name"]
+      }
+    },
+    {
+      name: "delete_personal_access_token",
+      description: "Delete a personal access token",
+      inputSchema: { type: "object", properties: { id: idParam }, required: ["id"] }
+    }
+  ],
+  handlers: {
+    // User Groups
+    async list_user_groups(args, { client: client2 }) {
+      return successResult(await client2.listUserGroups(args));
+    },
+    async create_user_group(args, { client: client2 }) {
+      return successResult(await client2.createUserGroup(args));
+    },
+    // Invites
+    async list_invites(args, { client: client2 }) {
+      return successResult(await client2.listInvites(args));
+    },
+    async create_invite(args, { client: client2 }) {
+      return successResult(await client2.createInvite(args));
+    },
+    async update_invite(args, { client: client2 }) {
+      const { id, ...data } = args;
+      return successResult(await client2.updateInvite(id, data));
+    },
+    async resend_invite(args, { client: client2 }) {
+      return successResult(await client2.resendInvite(args.id));
+    },
+    // Filter Groups
+    async list_filter_groups(args, { client: client2 }) {
+      return successResult(await client2.listFilterGroups(args));
+    },
+    async create_filter_group(args, { client: client2 }) {
+      return successResult(await client2.createFilterGroup(args));
+    },
+    // Search Queries
+    async list_search_queries(args, { client: client2 }) {
+      return successResult(await client2.listSearchQueries(args));
+    },
+    async create_search_query(args, { client: client2 }) {
+      return successResult(await client2.createSearchQuery(args));
+    },
+    // Crop Presets
+    async list_crop_presets(args, { client: client2 }) {
+      return successResult(await client2.listCropPresets(args));
+    },
+    async create_crop_preset(args, { client: client2 }) {
+      return successResult(await client2.createCropPreset(args));
+    },
+    // Uploads
+    async can_upload(_args, { client: client2 }) {
+      return successResult(await client2.canUpload());
+    },
+    async list_uploads(args, { client: client2 }) {
+      return successResult(await client2.listUploads(args));
+    },
+    async add_assets_to_upload(args, { client: client2 }) {
+      await client2.addAssetsToUpload(args.guid, args.asset_ids);
+      return successResult({ success: true });
+    },
+    // Contributions
+    async list_contributions(args, { client: client2 }) {
+      return successResult(await client2.listContributions(args));
+    },
+    async get_contribution(args, { client: client2 }) {
+      return successResult(await client2.getContribution(args.id));
+    },
+    // Personal Access Tokens
+    async list_personal_access_tokens(args, { client: client2 }) {
+      return successResult(await client2.listPersonalAccessTokens(args));
+    },
+    async create_personal_access_token(args, { client: client2 }) {
+      return successResult(await client2.createPersonalAccessToken(args));
+    },
+    async delete_personal_access_token(args, { client: client2 }) {
+      await client2.deletePersonalAccessToken(args.id);
+      return successResult({ success: true });
+    }
+  }
+};
+// src/tools/index.ts
+var allToolModules = [
+  userTools,
+  assetTools,
+  groupTools,
+  tagTools,
+  rightsTools,
+  sharingTools,
+  jobTools,
+  metaTools,
+  workflowTools,
+  socialTools,
+  downloadTools,
+  webhookTools,
+  adminTools
+];
+var toolDefinitions = allToolModules.flatMap((m) => m.definitions);
+var allHandlers = {};
+for (const module of allToolModules) {
+  Object.assign(allHandlers, module.handlers);
+}
+async function handleTool(name, args, context) {
+  const handler = allHandlers[name];
+  if (!handler) {
+    return errorResult(`Unknown tool: ${name}`);
+  }
+  try {
+    return await handler(args, context);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error occurred";
+    return errorResult(message);
+  }
+}
+// src/resources/index.ts
+var resourceTemplates = [
+  {
+    uriTemplate: "mediagraph://asset/{id}",
+    name: "Mediagraph Asset",
+    description: "Get details about a specific asset by ID or GUID",
+    mimeType: "application/json"
+  },
+  {
+    uriTemplate: "mediagraph://collection/{id}",
+    name: "Mediagraph Collection",
+    description: "Get details about a specific collection",
+    mimeType: "application/json"
+  },
+  {
+    uriTemplate: "mediagraph://lightbox/{id}",
+    name: "Mediagraph Lightbox",
+    description: "Get details about a specific lightbox",
+    mimeType: "application/json"
+  },
+  {
+    uriTemplate: "mediagraph://search",
+    name: "Mediagraph Search",
+    description: "Search for assets with query parameters",
+    mimeType: "application/json"
+  }
+];
+function parseUri(uri) {
+  const url = new URL(uri);
+  const pathParts = url.pathname.split("/").filter(Boolean);
+  if (pathParts.length === 0) {
+    throw new Error("Invalid resource URI");
+  }
+  const type = pathParts[0];
+  const id = pathParts[1];
+  const query = url.searchParams;
+  return { type, id, query };
+}
+async function readResource(uri, context) {
+  const { client: client2 } = context;
+  const { type, id, query } = parseUri(uri);
+  try {
+    switch (type) {
+      case "asset": {
+        if (!id) {
+          throw new Error("Asset ID is required");
+        }
+        const asset = await client2.getAsset(id, {
+          include_renditions: true,
+          include_meta: true
+        });
+        return {
+          uri,
+          mimeType: "application/json",
+          text: JSON.stringify(asset, null, 2)
+        };
+      }
+      case "collection": {
+        if (!id) {
+          throw new Error("Collection ID is required");
+        }
+        const collection = await client2.getCollection(id);
+        const assets = await client2.searchAssets({
+          collection_id: parseInt(id, 10),
+          per_page: 50
+        });
+        return {
+          uri,
+          mimeType: "application/json",
+          text: JSON.stringify({ ...collection, assets: assets.assets }, null, 2)
+        };
+      }
+      case "lightbox": {
+        if (!id) {
+          throw new Error("Lightbox ID is required");
+        }
+        const lightbox = await client2.getLightbox(id);
+        const assets = await client2.searchAssets({
+          lightbox_id: parseInt(id, 10),
+          per_page: 50
+        });
+        return {
+          uri,
+          mimeType: "application/json",
+          text: JSON.stringify({ ...lightbox, assets: assets.assets }, null, 2)
+        };
+      }
+      case "search": {
+        const searchParams = {
+          q: query?.get("q") || void 0,
+          page: query?.has("page") ? parseInt(query.get("page"), 10) : void 0,
+          per_page: query?.has("per_page") ? parseInt(query.get("per_page"), 10) : 25,
+          tags: query?.getAll("tags") || void 0,
+          collection_id: query?.has("collection_id") ? parseInt(query.get("collection_id"), 10) : void 0,
+          storage_folder_id: query?.has("storage_folder_id") ? parseInt(query.get("storage_folder_id"), 10) : void 0
+        };
+        const results = await client2.searchAssets(searchParams);
+        return {
+          uri,
+          mimeType: "application/json",
+          text: JSON.stringify(results, null, 2)
+        };
+      }
+      default:
+        throw new Error(`Unknown resource type: ${type}`);
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    return {
+      uri,
+      mimeType: "text/plain",
+      text: `Error reading resource: ${message}`
+    };
+  }
+}
+async function listResources(context) {
+  const resources = [];
+  try {
+    const recentAssets = await context.client.searchAssets({ per_page: 10 });
+    for (const asset of recentAssets.assets) {
+      resources.push({
+        uri: `mediagraph://asset/${asset.guid}`,
+        name: `Asset: ${asset.filename}`,
+        description: asset.title || asset.description || `${asset.file_type} file`,
+        mimeType: "application/json"
+      });
+    }
+    const collections = await context.client.listCollections({ per_page: 10 });
+    for (const collection of collections) {
+      resources.push({
+        uri: `mediagraph://collection/${collection.id}`,
+        name: `Collection: ${collection.name}`,
+        description: collection.description || `Collection with ${collection.visible_assets_count || 0} assets`,
+        mimeType: "application/json"
+      });
+    }
+    const lightboxes = await context.client.listLightboxes({ per_page: 10 });
+    for (const lightbox of lightboxes) {
+      resources.push({
+        uri: `mediagraph://lightbox/${lightbox.id}`,
+        name: `Lightbox: ${lightbox.name}`,
+        description: lightbox.description || `Lightbox with ${lightbox.visible_assets_count || 0} assets`,
+        mimeType: "application/json"
+      });
+    }
+  } catch (error) {
+    console.error("Error listing resources:", error);
+  }
+  return resources;
+}
+// src/index.ts
+var config = {
+  clientId: process.env.MEDIAGRAPH_CLIENT_ID || "",
+  clientSecret: process.env.MEDIAGRAPH_CLIENT_SECRET,
+  apiUrl: process.env.MEDIAGRAPH_API_URL || "https://api.mediagraph.io",
+  oauthUrl: process.env.MEDIAGRAPH_OAUTH_URL || "https://mediagraph.io",
+  redirectPort: parseInt(process.env.MEDIAGRAPH_REDIRECT_PORT || "52584", 10)
+};
+var tokenStore = new TokenStore();
+var oauthHandler = new OAuthHandler({
+  clientId: config.clientId,
+  clientSecret: config.clientSecret,
+  oauthUrl: config.oauthUrl,
+  redirectPort: config.redirectPort
+});
+var currentTokens = null;
+async function getAccessToken() {
+  if (currentTokens && Date.now() < currentTokens.expires_at - 3e5) {
+    return currentTokens.access_token;
+  }
+  const stored = tokenStore.load();
+  if (stored?.tokens) {
+    if (Date.now() < stored.tokens.expires_at - 3e5) {
+      currentTokens = stored.tokens;
+      return currentTokens.access_token;
+    }
+    if (stored.tokens.refresh_token) {
+      try {
+        const newTokens = await oauthHandler.refreshToken(stored.tokens.refresh_token);
+        currentTokens = newTokens;
+        tokenStore.save({
+          ...stored,
+          tokens: newTokens
+        });
+        return newTokens.access_token;
+      } catch (error) {
+        console.error("Failed to refresh token:", error);
+      }
+    }
+  }
+  return null;
+}
+var client = new MediagraphClient({
+  apiUrl: config.apiUrl,
+  getAccessToken
+});
+var toolContext = { client };
+var resourceContext = { client };
+var server = new Server(
+  {
+    name: "mediagraph-mcp",
+    version: "1.0.0"
+  },
+  {
+    capabilities: {
+      tools: {},
+      resources: {}
+    }
+  }
+);
+server.setRequestHandler(ListToolsRequestSchema, async () => {
+  return {
+    tools: toolDefinitions
+  };
+});
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  const { name, arguments: args } = request.params;
+  const token = await getAccessToken();
+  if (!token) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Not authenticated with Mediagraph. Please run the authorization flow first.
+To authorize:
+1. Run: npx @mediagraph/mcp authorize
+2. Complete the OAuth flow in your browser
+3. Return here and try again
+Or set your credentials via environment variables:
+- MEDIAGRAPH_CLIENT_ID (required)
+- MEDIAGRAPH_CLIENT_SECRET (optional, for confidential clients)
+`
+        }
+      ],
+      isError: true
+    };
+  }
+  const result = await handleTool(name, args || {}, toolContext);
+  return {
+    content: result.content,
+    isError: result.isError
+  };
+});
+server.setRequestHandler(ListResourceTemplatesRequestSchema, async () => {
+  return {
+    resourceTemplates
+  };
+});
+server.setRequestHandler(ListResourcesRequestSchema, async () => {
+  const token = await getAccessToken();
+  if (!token) {
+    return { resources: [] };
+  }
+  const resources = await listResources(resourceContext);
+  return { resources };
+});
+server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
+  const { uri } = request.params;
+  const token = await getAccessToken();
+  if (!token) {
+    return {
+      contents: [
+        {
+          uri,
+          mimeType: "text/plain",
+          text: "Not authenticated with Mediagraph. Please authorize first."
+        }
+      ]
+    };
+  }
+  const content = await readResource(uri, resourceContext);
+  return {
+    contents: [content]
+  };
+});
+async function runAuthorize() {
+  if (!config.clientId) {
+    console.error("Error: MEDIAGRAPH_CLIENT_ID environment variable is required");
+    console.error("");
+    console.error("Get your client ID from your Mediagraph organization settings.");
+    process.exit(1);
+  }
+  console.log("Starting Mediagraph OAuth authorization...");
+  console.log("");
+  const authUrl = oauthHandler.getAuthorizationUrl();
+  console.log("Please open this URL in your browser:");
+  console.log("");
+  console.log(authUrl);
+  console.log("");
+  console.log("Waiting for authorization callback...");
+  try {
+    const { code } = await oauthHandler.waitForCallback();
+    console.log("");
+    console.log("Authorization code received. Exchanging for tokens...");
+    const tokens = await oauthHandler.exchangeCode(code);
+    console.log("Tokens received successfully.");
+    currentTokens = tokens;
+    const whoami = await client.whoami();
+    const storedData = {
+      tokens,
+      organizationId: whoami.organization.id,
+      organizationName: whoami.organization.name,
+      userId: whoami.user.id,
+      userEmail: whoami.user.email
+    };
+    tokenStore.save(storedData);
+    console.log("");
+    console.log("Successfully authorized!");
+    console.log(`Organization: ${whoami.organization.name}`);
+    console.log(`User: ${whoami.user.full_name} (${whoami.user.email})`);
+    console.log("");
+    console.log("You can now use the Mediagraph MCP server.");
+  } catch (error) {
+    console.error("Authorization failed:", error instanceof Error ? error.message : error);
+    process.exit(1);
+  }
+}
+async function runLogout() {
+  const stored = tokenStore.load();
+  if (stored?.tokens?.access_token) {
+    try {
+      await oauthHandler.revokeToken(stored.tokens.access_token);
+      console.log("Token revoked successfully.");
+    } catch (error) {
+      console.error("Warning: Failed to revoke token:", error);
+    }
+  }
+  tokenStore.clear();
+  console.log("Logged out. Stored tokens have been cleared.");
+}
+async function runStatus() {
+  const stored = tokenStore.load();
+  if (!stored?.tokens) {
+    console.log("Status: Not authenticated");
+    console.log("");
+    console.log("Run: npx @mediagraph/mcp authorize");
+    return;
+  }
+  const isExpired = Date.now() >= stored.tokens.expires_at;
+  const expiresIn = Math.round((stored.tokens.expires_at - Date.now()) / 1e3 / 60);
+  console.log("Status: Authenticated");
+  console.log(`Organization: ${stored.organizationName || "Unknown"}`);
+  console.log(`User: ${stored.userEmail || "Unknown"}`);
+  console.log(`Token Status: ${isExpired ? "Expired" : `Valid (expires in ${expiresIn} minutes)`}`);
+  console.log(`Refresh Token: ${stored.tokens.refresh_token ? "Available" : "Not available"}`);
+}
+async function runServer() {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error("Mediagraph MCP server started");
+}
+async function main() {
+  const args = process.argv.slice(2);
+  const command = args[0];
+  switch (command) {
+    case "authorize":
+    case "auth":
+    case "login":
+      await runAuthorize();
+      break;
+    case "logout":
+    case "revoke":
+      await runLogout();
+      break;
+    case "status":
+    case "whoami":
+      await runStatus();
+      break;
+    case "help":
+    case "--help":
+    case "-h":
+      console.log(`
+Mediagraph MCP Server
+Usage: npx @mediagraph/mcp [command]
+Commands:
+  (no command)  Start the MCP server (for Claude Desktop)
+  authorize     Authorize with Mediagraph via OAuth
+  logout        Log out and revoke tokens
+  status        Show current authentication status
+  help          Show this help message
+Environment Variables:
+  MEDIAGRAPH_CLIENT_ID       Your OAuth client ID (required)
+  MEDIAGRAPH_CLIENT_SECRET   Your OAuth client secret (optional)
+  MEDIAGRAPH_API_URL         API URL (default: https://api.mediagraph.io)
+  MEDIAGRAPH_OAUTH_URL       OAuth URL (default: https://mediagraph.io)
+  MEDIAGRAPH_REDIRECT_PORT   Local callback port (default: 52584)
+Example:
+  # First, authorize with Mediagraph
+  MEDIAGRAPH_CLIENT_ID=your-client-id npx @mediagraph/mcp authorize
+  # Then configure Claude Desktop to use the MCP server
+  # See README for configuration details
+`);
+      break;
+    default:
+      await runServer();
+      break;
+  }
+}
+main().catch((error) => {
+  console.error("Fatal error:", error);
+  process.exit(1);
+});