adoptai-mcp 1.0.0

package/dist/integrations/canva/tools.js

@@ -0,0 +1,1315 @@
+import axios from 'axios';
+import { Buffer } from 'node:buffer';
+import { buildAuthHeaders, ensureAccessToken } from './auth.js';
+
+const BASE_URL = "https://api.canva.com/rest/v1";
+
+function handleError(err) {
+  const status = err.response?.status;
+  const data = err.response?.data;
+  const msg =
+    (typeof data?.message === 'string' && data.message) ||
+    (typeof data?.error_description === 'string' && data.error_description) ||
+    (typeof data?.error === 'string' && data.error) ||
+    err.message;
+  if (status === 401) throw new Error('Token invalid or expired.\nRun: npx adoptai-canva-mcp --client cursor');
+  if (status === 403) throw new Error('Insufficient permissions. Check OAuth scopes on your Canva integration.');
+  if (status === 404) throw new Error('Resource not found. Check your parameters.');
+  if (status === 429) throw new Error('Rate limit exceeded. Please wait and try again.');
+  throw new Error(msg || 'Canva API request failed');
+}
+
+function text(payload) {
+  return { content: [{ type: 'text', text: JSON.stringify(payload, null, 2) }] };
+}
+
+/**
+ * @param {string} method
+ * @param {string} pathTemplate - e.g. /designs/{designId}
+ * @param {Record<string, unknown>} params - path keys substituted; rest → query (GET/DELETE) or JSON body
+ * @param {{ headers?: Record<string, string>, rawBody?: unknown, responseType?: string }} [opts]
+ */
+async function apiRequest(method, pathTemplate, params = {}, opts = {}) {
+  await ensureAccessToken();
+  const headers = {
+    ...(!['GET', 'DELETE'].includes(method) ? { 'Content-Type': 'application/json' } : {}),
+    ...buildAuthHeaders(),
+    ...opts.headers,
+  };
+  let path = pathTemplate;
+  const p = { ...params };
+  const pathKeys = [...path.matchAll(/\{([^}]+)\}/g)].map((m) => m[1]);
+  for (const key of pathKeys) {
+    const v = p[key];
+    if (v === undefined || v === null || v === '') throw new Error(`Missing required path parameter: ${key}`);
+    path = path.replace(`{${key}}`, encodeURIComponent(String(v)));
+    delete p[key];
+  }
+  const url = BASE_URL.replace(/\/$/, '') + path;
+  const isBodyless = method === 'GET' || method === 'DELETE';
+  let data = opts.rawBody;
+  const query = {};
+  if (!isBodyless && opts.rawBody === undefined) {
+    const body = {};
+    for (const [k, v] of Object.entries(p)) {
+      if (v !== undefined && v !== null) body[k] = v;
+    }
+    if (Object.keys(body).length) data = body;
+  } else if (isBodyless) {
+    for (const [k, v] of Object.entries(p)) {
+      if (v !== undefined && v !== null && v !== '') query[k] = v;
+    }
+  }
+  try {
+    const res = await axios({
+      method,
+      url,
+      headers,
+      params: isBodyless && Object.keys(query).length ? query : undefined,
+      data,
+      timeout: 120000,
+      responseType: opts.responseType || 'json',
+      validateStatus: () => true,
+    });
+    if (res.status >= 400) {
+      const fake = new Error();
+      fake.response = res;
+      handleError(fake);
+    }
+    if (res.status === 204 || res.data === '' || res.data === undefined) return { ok: true, status: res.status };
+    return res.data;
+  } catch (e) {
+    if (e.response) handleError(e);
+    throw e;
+  }
+}
+
+// --- Smart / composite tools (see product spec) ---
+function sleep(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+
+async function pollJob(getFn, { maxAttempts = 120, intervalMs = 1500 } = {}) {
+  let last;
+  for (let i = 0; i < maxAttempts; i++) {
+    last = await getFn();
+    const status = last?.job?.status ?? last?.status;
+    if (status === 'success' || status === 'failed') return last;
+    await sleep(intervalMs);
+  }
+  return last;
+}
+
+
+const generatedTools = [
+  {
+    name: "get_app_jwks",
+    description: "Returns the Json Web Key Set (public keys) of an app. These keys are used to verify JWTs sent to app backends.",
+    inputSchema: {
+      "type": "object",
+      "properties": {
+        "appId": {
+          "type": "string",
+          "description": "The app ID."
+        }
+      },
+      "required": [
+        "appId"
+      ]
+    },
+    handler: async (params) => text(await apiRequest("GET", "/apps/{appId}/jwks", params)),
+  },
+  {
+    name: "get_asset",
+    description: "You can retrieve the metadata of an asset by specifying its `assetId`.",
+    inputSchema: {
+      "type": "object",
+      "properties": {
+        "assetId": {
+          "type": "string",
+          "description": "The ID of the asset."
+        }
+      },
+      "required": [
+        "assetId"
+      ]
+    },
+    handler: async (params) => text(await apiRequest("GET", "/assets/{assetId}", params)),
+  },
+  {
+    name: "get_asset_upload_job",
+    description: "Get the result of an asset upload job that was created using the [Create asset upload job API](https://www.canva.dev/docs/connect/api-reference/assets/create-asset-upload-job/). You might need to make multiple requests to this endpoint until you get a `success` or `failed` status. For more information on the workflow for using asynchronous jobs, see [API requests and responses](https://www.canva.dev/docs/connect/api-requests-responses/#asynchronous-job-endpoints).",
+    inputSchema: {
+      "type": "object",
+      "properties": {
+        "jobId": {
+          "type": "string",
+          "description": "The asset upload job ID."
+        }
+      },
+      "required": [
+        "jobId"
+      ]
+    },
+    handler: async (params) => text(await apiRequest("GET", "/asset-uploads/{jobId}", params)),
+  },
+  {
+    name: "get_brand_template",
+    description: "WARNING: Brand templates were migrated to use a new ID format in September 2025. If your integration stores brand template IDs, you'll need to migrate to use the new IDs. Old brand template IDs will continue to be accepted for 6 months to give you time to migrate to the new IDs. AVAILABILITY: To use this API, your integration must act on behalf of a user that's a member of a [Canva Enterprise](https://www.canva.com/enterprise/) organization. Retrieves the metadata for a brand template.",
+    inputSchema: {
+      "type": "object",
+      "properties": {
+        "brandTemplateId": {
+          "type": "string",
+          "description": "The brand template ID."
+        }
+      },
+      "required": [
+        "brandTemplateId"
+      ]
+    },
+    handler: async (params) => text(await apiRequest("GET", "/brand-templates/{brandTemplateId}", params)),
+  },
+  {
+    name: "get_design",
+    description: "Gets the metadata for a design. This includes owner information, URLs for editing and viewing, and thumbnail information.",
+    inputSchema: {
+      "type": "object",
+      "properties": {
+        "designId": {
+          "type": "string",
+          "description": "The design ID."
+        }
+      },
+      "required": [
+        "designId"
+      ]
+    },
+    handler: async (params) => text(await apiRequest("GET", "/designs/{designId}", params)),
+  },
+  {
+    name: "get_design_autofill_job",
+    description: "AVAILABILITY: To use this API, your integration must act on behalf of a user that's a member of a [Canva Enterprise](https://www.canva.com/enterprise/) organization. Get the result of a design autofill job that was created using the [Create design autofill job API](https://www.canva.dev/docs/connect/api-reference/autofills/create-design-autofill-job/). You might need to make multiple requests to this endpoint until you get a `success` or `failed` status. For more information on the workflow for using asynchronous jobs, see [API requests and responses](https://www.canva.dev/docs/connect/api-requests-responses/#asynchronous-job-endpoints).",
+    inputSchema: {
+      "type": "object",
+      "properties": {
+        "jobId": {
+          "type": "string",
+          "description": "The design autofill job ID."
+        }
+      },
+      "required": [
+        "jobId"
+      ]
+    },
+    handler: async (params) => text(await apiRequest("GET", "/autofills/{jobId}", params)),
+  },
+  {
+    name: "get_design_export_formats",
+    description: "Lists the available file formats for [exporting a design](https://www.canva.dev/docs/connect/api-reference/exports/create-design-export-job/). <Note> The available export formats depend on the design type and the types of pages in the design. In general, the available export formats returned are only those that are supported by every page type in the design. </Note>",
+    inputSchema: {
+      "type": "object",
+      "properties": {
+        "designId": {
+          "type": "string",
+          "description": "The design ID."
+        }
+      },
+      "required": [
+        "designId"
+      ]
+    },
+    handler: async (params) => text(await apiRequest("GET", "/designs/{designId}/export-formats", params)),
+  },
+  {
+    name: "get_design_export_job",
+    description: "Gets the result of a design export job that was created using the [Create design export job API](https://www.canva.dev/docs/connect/api-reference/exports/create-design-export-job/). If the job is successful, the response includes an array of download URLs. Depending on the design type and export format, there is a download URL for each page in the design. The download URLs are only valid for 24 hours. You might need to make multiple requests to this endpoint until you get a `success` or `failed` status. For more information on the workflow for using asynchronous jobs, see [API requests and responses](https://www.canva.dev/docs/connect/api-requests-responses/#asynchronous-job-endpoints).",
+    inputSchema: {
+      "type": "object",
+      "properties": {
+        "exportId": {
+          "type": "string",
+          "description": "The export job ID."
+        }
+      },
+      "required": [
+        "exportId"
+      ]
+    },
+    handler: async (params) => text(await apiRequest("GET", "/exports/{exportId}", params)),
+  },
+  {
+    name: "get_design_import_job",
+    description: "Gets the result of a design import job created using the [Create design import job API](https://www.canva.dev/docs/connect/api-reference/design-imports/create-design-import-job/). You might need to make multiple requests to this endpoint until you get a `success` or `failed` status. For more information on the workflow for using asynchronous jobs, see [API requests and responses](https://www.canva.dev/docs/connect/api-requests-responses/#asynchronous-job-endpoints).",
+    inputSchema: {
+      "type": "object",
+      "properties": {
+        "jobId": {
+          "type": "string",
+          "description": "The design import job ID."
+        }
+      },
+      "required": [
+        "jobId"
+      ]
+    },
+    handler: async (params) => text(await apiRequest("GET", "/imports/{jobId}", params)),
+  },
+  {
+    name: "get_design_pages",
+    description: "<Warning> This API is currently provided as a preview. Be aware of the following: - There might be unannounced breaking changes. - Any breaking changes to preview APIs won't produce a new [API version](https://www.canva.dev/docs/connect/versions/). - Public integrations that use preview APIs will not pass the review process, and can't be made available to all Canva users. </Warning> Lists metadata for pages in a design, such as page-specific thumbnails. For the specified design, you can provide `offset` and `limit` values to specify the range of pages to return. NOTE: Some design types don't have pages (for example, Canva docs).",
+    inputSchema: {
+      "type": "object",
+      "properties": {
+        "designId": {
+          "type": "string",
+          "description": "The design ID."
+        },
+        "offset": {
+          "type": "number",
+          "description": "The page index to start the range of pages to return.\n\nPages are indexed using one-based numbering, so the first page in a design has the index value `1`.\n"
+        },
+        "limit": {
+          "type": "number",
+          "description": "The number of pages to return, starting at the page index specified using the `offset` parameter."
+        }
+      },
+      "required": [
+        "designId"
+      ]
+    },
+    handler: async (params) => text(await apiRequest("GET", "/designs/{designId}/pages", params)),
+  },
+  {
+    name: "get_design_resize_job",
+    description: "AVAILABILITY: To use this API, your integration must act on behalf of a user that's on a Canva plan with premium features (such as Canva Pro). Gets the result of a design resize job that was created using the [Create design resize job API](https://www.canva.dev/docs/connect/api-reference/resizes/create-design-resize-job/). If the job is successful, the response includes a summary of the new resized design, including its metadata. You might need to make multiple requests to this endpoint until you get a `success` or `failed` status. For more information on the workflow for using asynchronous jobs, see [API requests and responses](https://www.canva.dev/docs/connect/api-requests-responses/#asynchronous-job-endpoints).",
+    inputSchema: {
+      "type": "object",
+      "properties": {
+        "jobId": {
+          "type": "string",
+          "description": "The design resize job ID."
+        }
+      },
+      "required": [
+        "jobId"
+      ]
+    },
+    handler: async (params) => text(await apiRequest("GET", "/resizes/{jobId}", params)),
+  },
+  {
+    name: "get_folder",
+    description: "Gets the name and other details of a folder using a folder's `folderID`.",
+    inputSchema: {
+      "type": "object",
+      "properties": {
+        "folderId": {
+          "type": "string",
+          "description": "The folder ID."
+        }
+      },
+      "required": [
+        "folderId"
+      ]
+    },
+    handler: async (params) => text(await apiRequest("GET", "/folders/{folderId}", params)),
+  },
+  {
+    name: "get_oidc_jwks",
+    description: "Gets the JSON Web Key Set (public keys) for OIDC. These keys are used to verify JWTs in OpenID Connect flows.",
+    inputSchema: {
+      "type": "object",
+      "properties": {},
+      "required": []
+    },
+    handler: async (params) => text(await apiRequest("GET", "/oidc/jwks", params)),
+  },
+  {
+    name: "get_reply",
+    description: "<Warning> This API is currently provided as a preview. Be aware of the following: - There might be unannounced breaking changes. - Any breaking changes to preview APIs won't produce a new [API version](https://www.canva.dev/docs/connect/versions/). - Public integrations that use preview APIs will not pass the review process, and can't be made available to all Canva users. </Warning> Gets a reply to a comment or suggestion thread on a design. For information on comments and how they're used in the Canva UI, see the [Canva Help Center](https://www.canva.com/help/comments/).",
+    inputSchema: {
+      "type": "object",
+      "properties": {
+        "designId": {
+          "type": "string",
+          "description": "The design ID."
+        },
+        "threadId": {
+          "type": "string",
+          "description": "The ID of the thread."
+        },
+        "replyId": {
+          "type": "string",
+          "description": "The ID of the reply."
+        }
+      },
+      "required": [
+        "designId",
+        "threadId",
+        "replyId"
+      ]
+    },
+    handler: async (params) => text(await apiRequest("GET", "/designs/{designId}/comments/{threadId}/replies/{replyId}", params)),
+  },
+  {
+    name: "get_thread",
+    description: "<Warning> This API is currently provided as a preview. Be aware of the following: - There might be unannounced breaking changes. - Any breaking changes to preview APIs won't produce a new [API version](https://www.canva.dev/docs/connect/versions/). - Public integrations that use preview APIs will not pass the review process, and can't be made available to all Canva users. </Warning> Gets a comment or suggestion thread on a design. To retrieve a reply to a comment thread, use the [Get reply](https://www.canva.dev/docs/connect/api-reference/comments/get-reply/) API. For information on comments and how they're used in the Canva UI, see the [Canva Help Center](https://www.canva.com/help/comments/).",
+    inputSchema: {
+      "type": "object",
+      "properties": {
+        "designId": {
+          "type": "string",
+          "description": "The design ID."
+        },
+        "threadId": {
+          "type": "string",
+          "description": "The ID of the thread."
+        }
+      },
+      "required": [
+        "designId",
+        "threadId"
+      ]
+    },
+    handler: async (params) => text(await apiRequest("GET", "/designs/{designId}/comments/{threadId}", params)),
+  },
+  {
+    name: "get_url_asset_upload_job",
+    description: "<Warning> This API is currently provided as a preview. Be aware of the following: - There might be unannounced breaking changes. - Any breaking changes to preview APIs won't produce a new [API version](https://www.canva.dev/docs/connect/versions/). - Public integrations that use preview APIs will not pass the review process, and can't be made available to all Canva users. </Warning> Get the result of an asset upload job that was created using the [Create asset upload job via URL API](https://www.canva.dev/docs/connect/api-reference/assets/create-url-asset-upload-job/). You might need to make multiple requests to this endpoint until you get a `success` or `failed` status. For more information on the workflow for using asynchronous jobs, see [API requests and responses](https://www.canva.dev/docs/connect/api-requests-responses/#asynchronous-job-endpoints).",
+    inputSchema: {
+      "type": "object",
+      "properties": {
+        "jobId": {
+          "type": "string",
+          "description": "The asset upload job ID."
+        }
+      },
+      "required": [
+        "jobId"
+      ]
+    },
+    handler: async (params) => text(await apiRequest("GET", "/url-asset-uploads/{jobId}", params)),
+  },
+  {
+    name: "get_url_import_job",
+    description: "Gets the result of a URL import job created using the [Create URL import job API](https://www.canva.dev/docs/connect/api-reference/design-imports/create-url-import-job/). You might need to make multiple requests to this endpoint until you get a `success` or `failed` status. For more information on the workflow for using asynchronous jobs, see [API requests and responses](https://www.canva.dev/docs/connect/api-requests-responses/#asynchronous-job-endpoints).",
+    inputSchema: {
+      "type": "object",
+      "properties": {
+        "jobId": {
+          "type": "string",
+          "description": "The ID of the URL import job."
+        }
+      },
+      "required": [
+        "jobId"
+      ]
+    },
+    handler: async (params) => text(await apiRequest("GET", "/url-imports/{jobId}", params)),
+  },
+  {
+    name: "get_user_capabilities",
+    description: "Lists the API capabilities for the user account associated with the provided access token. For more information, see [Capabilities](https://www.canva.dev/docs/connect/capabilities/).",
+    inputSchema: {
+      "type": "object",
+      "properties": {},
+      "required": []
+    },
+    handler: async (params) => text(await apiRequest("GET", "/users/me/capabilities", params)),
+  },
+  {
+    name: "get_user_profile",
+    description: "Currently, this returns the display name of the user account associated with the provided access token. More user information is expected to be included in the future.",
+    inputSchema: {
+      "type": "object",
+      "properties": {},
+      "required": []
+    },
+    handler: async (params) => text(await apiRequest("GET", "/users/me/profile", params)),
+  },
+  {
+    name: "list_designs",
+    description: "Lists metadata for all the designs in a Canva user's [projects](https://www.canva.com/help/find-designs-and-folders/). You can also: - Use search terms to filter the listed designs. - Show designs either created by, or shared with the user. - Sort the results.",
+    inputSchema: {
+      "type": "object",
+      "properties": {
+        "query": {
+          "type": "string",
+          "description": "Lets you search the user's designs, and designs shared with the user, using a search term or terms."
+        },
+        "continuation": {
+          "type": "string",
+          "description": "If the success response contains a continuation token, the list contains more designs\nyou can list. You can use this token as a query parameter and retrieve more\ndesigns from the list, for example\n`/v1/designs?continuation={continuation}`.\n\nTo retrieve all of a user's designs, you might need to make multiple requests."
+        },
+        "ownership": {
+          "type": "string",
+          "description": "Filter the list of designs based on the user's ownership of the designs."
+        },
+        "sort_by": {
+          "type": "string",
+          "description": "Sort the list of designs."
+        },
+        "limit": {
+          "type": "number",
+          "description": "The number of designs to return."
+        }
+      },
+      "required": []
+    },
+    handler: async (params) => text(await apiRequest("GET", "/designs", params)),
+  },
+  {
+    name: "list_folder_items",
+    description: "Lists the items in a folder, including each item's `type`. Folders can contain: - Other folders. - Designs, such as Instagram posts, Presentations, and Documents ([Canva Docs](https://www.canva.com/create/documents/)). - Image assets. Currently, video assets are not returned in the response.",
+    inputSchema: {
+      "type": "object",
+      "properties": {
+        "folderId": {
+          "type": "string",
+          "description": "The folder ID."
+        },
+        "continuation": {
+          "type": "string",
+          "description": "If the success response contains a continuation token, the folder contains more items\nyou can list. You can use this token as a query parameter and retrieve more\nitems from the list, for example\n`/v1/folders/{folderId}/items?continuation={continuation}`.\n\nTo retrieve all the items in a folder, you might need to make multiple requests."
+        },
+        "limit": {
+          "type": "number",
+          "description": "The limit parameter"
+        },
+        "item_types": {
+          "type": "array",
+          "description": "Filter the folder items to only return specified types. The available types are:\n`design`, `folder`, and `image`. To filter for more than one item type, provide a comma-\ndelimited list."
+        },
+        "sort_by": {
+          "type": "string",
+          "description": "Sort the list of folder items."
+        },
+        "pin_status": {
+          "type": "string",
+          "description": "Filter the folder items by their pinned status."
+        }
+      },
+      "required": [
+        "folderId"
+      ]
+    },
+    handler: async (params) => text(await apiRequest("GET", "/folders/{folderId}/items", params)),
+  },
+  {
+    name: "list_replies",
+    description: "<Warning> This API is currently provided as a preview. Be aware of the following: - There might be unannounced breaking changes. - Any breaking changes to preview APIs won't produce a new [API version](https://www.canva.dev/docs/connect/versions/). - Public integrations that use preview APIs will not pass the review process, and can't be made available to all Canva users. </Warning> Retrieves a list of replies for a comment or suggestion thread on a design. For information on comments and how they're used in the Canva UI, see the [Canva Help Center](https://www.canva.com/help/comments/).",
+    inputSchema: {
+      "type": "object",
+      "properties": {
+        "designId": {
+          "type": "string",
+          "description": "The design ID."
+        },
+        "threadId": {
+          "type": "string",
+          "description": "The ID of the thread."
+        },
+        "limit": {
+          "type": "number",
+          "description": "The limit parameter"
+        },
+        "continuation": {
+          "type": "string",
+          "description": "If the success response contains a continuation token, the list contains more items you can list. You can use this token as a query parameter and retrieve more items from the list, for example `?continuation={continuation}`.\n\nTo retrieve all items, you might need to make multiple requests."
+        }
+      },
+      "required": [
+        "designId",
+        "threadId"
+      ]
+    },
+    handler: async (params) => text(await apiRequest("GET", "/designs/{designId}/comments/{threadId}/replies", params)),
+  },
+  {
+    name: "user_info",
+    description: "Fetches the current UserInfo claims for the authorized user. This is the same fields returned by a id_token returns during authorization.",
+    inputSchema: {
+      "type": "object",
+      "properties": {},
+      "required": []
+    },
+    handler: async (params) => text(await apiRequest("GET", "/oidc/userinfo", params)),
+  },
+  {
+    name: "create_asset_upload_job",
+    description: "Starts a new [asynchronous job](https://www.canva.dev/docs/connect/api-requests-responses/#asynchronous-job-endpoints) to upload an asset to the user's content library. Supported file types for assets are listed in the [Assets API overview](https://www.canva.dev/docs/connect/api-reference/assets/). The request format for this endpoint is an `application/octet-stream` body of bytes. Attach information about the upload using an `Asset-Upload-Metadata` header. <Note> For more information on the workflow for using asynchronous jobs, see [API requests and responses](https://www.canva.dev/docs/connect/api-requests-responses/#asynchronous-job-endpoints). You can check the status and get the results of asset upload jobs created with this API using the [Get asset upload job API](https://www.canva.dev/docs/connect/api-reference/assets/get-asset-upload-job/). </Note>",
+    inputSchema: {
+      "type": "object",
+      "properties": {
+        "asset_upload_metadata": {
+          "type": "object",
+          "description": "Metadata for the binary upload (maps to Asset-Upload-Metadata header as JSON)."
+        },
+        "body_base64": {
+          "type": "string",
+          "description": "Base64-encoded file bytes for application/octet-stream body."
+        }
+      },
+      "required": [
+        "asset_upload_metadata",
+        "body_base64"
+      ]
+    },
+    handler: async (params) => {
+      const { body_base64, asset_upload_metadata, ...rest } = params;
+      await ensureAccessToken();
+      const pathTemplate = "/asset-uploads";
+      let path = pathTemplate;
+      const pathKeys = [...path.matchAll(/\{([^}]+)\}/g)].map((m) => m[1]);
+      const p = { ...rest };
+      for (const key of pathKeys) {
+        const v = p[key];
+        if (v === undefined || v === null || v === '') throw new Error(`Missing required path parameter: ${key}`);
+        path = path.replace(`{${key}}`, encodeURIComponent(String(v)));
+        delete p[key];
+      }
+      const url = BASE_URL.replace(/\/$/, '') + path;
+      const buf = Buffer.from(String(body_base64), 'base64');
+      const metaHeader = typeof asset_upload_metadata === 'string' ? asset_upload_metadata : JSON.stringify(asset_upload_metadata);
+      try {
+        const res = await axios.post(url, buf, {
+          headers: {
+            ...buildAuthHeaders(),
+            'Content-Type': 'application/octet-stream',
+            'Asset-Upload-Metadata': metaHeader,
+          },
+          timeout: 120000,
+          validateStatus: () => true,
+        });
+        if (res.status >= 400) { const fake = new Error(); fake.response = res; handleError(fake); }
+        return text(res.data);
+      } catch (e) { if (e.response) handleError(e); throw e; }
+    },
+  },
+  {
+    name: "create_design",
+    description: "Creates a new Canva design. To create a new design, you can either: - Use a preset design type. - Set height and width dimensions for a custom design. Additionally, you can also provide the `asset_id` of an asset in the user's [projects](https://www.canva.com/help/find-designs-and-folders/) to add to the new design. Currently, this only supports image assets. To list the assets in a folder in the user's projects, use the [List folder items API](https://www.canva.dev/docs/connect/api-reference/folders/list-folder-items/). NOTE: Blank designs created with this API are automatically deleted if they're not edited within 7 days. These blank designs bypass the user's Canva trash and are permanently deleted.",
+    inputSchema: {
+      "type": "object",
+      "properties": {
+        "design_type": {
+          "type": "object",
+          "description": "The desired design type."
+        },
+        "asset_id": {
+          "type": "string",
+          "description": "The ID of an asset to insert into the created design. Currently, this only supports image assets."
+        },
+        "title": {
+          "type": "string",
+          "description": "The name of the design."
+        }
+      },
+      "required": []
+    },
+    handler: async (params) => text(await apiRequest("POST", "/designs", params)),
+  },
+  {
+    name: "create_design_autofill_job",
+    description: "WARNING: Brand templates were migrated to use a new ID format in September 2025. If your integration stores brand template IDs, you'll need to migrate to use the new IDs. Old brand template IDs will continue to be accepted for 6 months to give you time to migrate to the new IDs. AVAILABILITY: To use this API, your integration must act on behalf of a user that's a member of a [Canva Enterprise](https://www.canva.com/enterprise/) organization. Starts a new [asynchronous job](https://www.canva.dev/docs/connect/api-requests-responses/#asynchronous-job-endpoints) to autofill a Canva design using a brand template and input data. To get a list of input data fields, use the [Get brand template dataset API](https://www.canva.dev/docs/connect/api-reference/brand-templates/get-brand-template-dataset/). Available data field types to autofill include: - Images - Text - Charts WARNING: Chart data fields are a [preview feature](https://www.canva.dev/docs/connect/#preview-apis). There might be unannounced breaking changes to this feature which won't produce a new API version. NOTE: For more information on the workflow for using asynchronous jobs, see [API requests and responses](https://www.canva.dev/docs/connect/api-requests-responses/#asynchronous-job-endpoints). You can check the status and get the results of autofill jobs created with this API using the [Get design autofill job API](https://www.canva.dev/docs/connect/api-reference/autofills/get-design-autofill-job/).",
+    inputSchema: {
+      "type": "object",
+      "properties": {
+        "brand_template_id": {
+          "type": "string",
+          "description": "ID of the input brand template."
+        },
+        "title": {
+          "type": "string",
+          "description": "Title to use for the autofilled design.\n\nIf no design title is provided, the autofilled design will have the same title as the brand template."
+        },
+        "data": {
+          "type": "object",
+          "description": "Data object containing the data fields and values to autofill."
+        }
+      },
+      "required": [
+        "brand_template_id",
+        "data"
+      ]
+    },
+    handler: async (params) => text(await apiRequest("POST", "/autofills", params)),
+  },
+  {
+    name: "create_design_export_job",
+    description: "Starts a new [asynchronous job](https://www.canva.dev/docs/connect/api-requests-responses/#asynchronous-job-endpoints) to export a file from Canva. Once the exported file is generated, you can download it using the URL(s) provided. The download URLs are only valid for 24 hours. The request requires the design ID and the exported file format type. Supported file formats (and export file type values): PDF (`pdf`), JPG (`jpg`), PNG (`png`), GIF (`gif`), Microsoft PowerPoint (`pptx`), and MP4 (`mp4`). <Note> This endpoint has the following additional rate limits: - **Integration throttle:** Each integration can export a maximum of 750 times per 5-minute window, and 5,000 times per 24-hour window. - **Document throttle:** Each document can be exported a maximum of 75 times per 5-minute window. - **User throttle:** Each user can export a maximum of 75 times per 5-minute window, and 500 times per 24-hour window. </Note> <Note> For more information on the workflow for using asynchronous jobs, see [API requests and responses](https://www.canva.dev/docs/connect/api-requests-responses/#asynchronous-job-endpoints). You can check the status and get the results of export jobs created with this API using the [Get design export job API](https://www.canva.dev/docs/connect/api-reference/exports/get-design-export-job/). </Note>",
+    inputSchema: {
+      "type": "object",
+      "properties": {
+        "design_id": {
+          "type": "string",
+          "description": "The design ID."
+        },
+        "format": {
+          "type": "object",
+          "description": "Details about the desired export format."
+        }
+      },
+      "required": [
+        "design_id",
+        "format"
+      ]
+    },
+    handler: async (params) => text(await apiRequest("POST", "/exports", params)),
+  },
+  {
+    name: "create_design_import_job",
+    description: "Starts a new [asynchronous job](https://www.canva.dev/docs/connect/api-requests-responses/#asynchronous-job-endpoints) to import an external file as a new design in Canva. The request format for this endpoint has an `application/octet-stream` body of bytes, and the information about the import is provided using an `Import-Metadata` header. Supported file types for imports are listed in [Design imports overview](https://www.canva.dev/docs/connect/api-reference/design-imports/#supported-file-types). <Note> For more information on the workflow for using asynchronous jobs, see [API requests and responses](https://www.canva.dev/docs/connect/api-requests-responses/#asynchronous-job-endpoints). You can check the status and get the results of design import jobs created with this API using the [Get design import job API](https://www.canva.dev/docs/connect/api-reference/design-imports/get-design-import-job/). </Note>",
+    inputSchema: {
+      "type": "object",
+      "properties": {
+        "body_base64": {
+          "type": "string",
+          "description": "Base64-encoded file bytes for application/octet-stream body."
+        }
+      },
+      "required": [
+        "body_base64"
+      ]
+    },
+    handler: async (params) => {
+      const { body_base64, asset_upload_metadata, ...rest } = params;
+      await ensureAccessToken();
+      const pathTemplate = "/imports";
+      let path = pathTemplate;
+      const pathKeys = [...path.matchAll(/\{([^}]+)\}/g)].map((m) => m[1]);
+      const p = { ...rest };
+      for (const key of pathKeys) {
+        const v = p[key];
+        if (v === undefined || v === null || v === '') throw new Error(`Missing required path parameter: ${key}`);
+        path = path.replace(`{${key}}`, encodeURIComponent(String(v)));
+        delete p[key];
+      }
+      const url = BASE_URL.replace(/\/$/, '') + path;
+      const buf = Buffer.from(String(body_base64), 'base64');
+      const metaHeader = typeof asset_upload_metadata === 'string' ? asset_upload_metadata : JSON.stringify(asset_upload_metadata);
+      try {
+        const res = await axios.post(url, buf, {
+          headers: {
+            ...buildAuthHeaders(),
+            'Content-Type': 'application/octet-stream',
+            'Asset-Upload-Metadata': metaHeader,
+          },
+          timeout: 120000,
+          validateStatus: () => true,
+        });
+        if (res.status >= 400) { const fake = new Error(); fake.response = res; handleError(fake); }
+        return text(res.data);
+      } catch (e) { if (e.response) handleError(e); throw e; }
+    },
+  },
+  {
+    name: "create_design_resize_job",
+    description: "AVAILABILITY: To use this API, your integration must act on behalf of a user that's on a Canva plan with premium features (such as Canva Pro). Starts a new [asynchronous job](https://www.canva.dev/docs/connect/api-requests-responses/#asynchronous-job-endpoints) to create a resized copy of a design. The new resized design is added to the top level of the user's [projects](https://www.canva.com/help/find-designs-and-folders/) (`root` folder). To resize a design into a new design, you can either: - Use a preset design type. - Set height and width dimensions for a custom design. Note the following behaviors and restrictions when resizing designs: - Designs can be resized to a maximum area of 25,000,000 pixels squared. - Resizing designs using the Connect API always creates a new design. In-place resizing is currently not available in the Connect API, but can be done in the Canva UI. - Resizing a multi-page design results in all pages of the design being resized. Resizing a section of a design is only available in the Canva UI. - [Canva docs](https://www.canva.com/create/documents/) can't be resized, and other design types can't be resized to a Canva doc. - Canva Code designs can't be resized, and other design types can't be resized to a Canva Code design. <Note> For more information on the workflow for using asynchronous jobs, see [API requests and responses](https://www.canva.dev/docs/connect/api-requests-responses/#asynchronous-job-endpoints). You can check the status and get the results of resize jobs created with this API using the [Get design resize job API](https://www.canva.dev/docs/connect/api-reference/resizes/get-design-resize-job/). </Note>",
+    inputSchema: {
+      "type": "object",
+      "properties": {
+        "design_id": {
+          "type": "string",
+          "description": "The design ID."
+        },
+        "design_type": {
+          "type": "object",
+          "description": "The desired design type."
+        }
+      },
+      "required": [
+        "design_id",
+        "design_type"
+      ]
+    },
+    handler: async (params) => text(await apiRequest("POST", "/resizes", params)),
+  },
+  {
+    name: "create_folder",
+    description: "Creates a folder in one of the following locations: - The top level of a Canva user's [projects](https://www.canva.com/help/find-designs-and-folders/) (using the ID `root`), - The user's Uploads folder (using the ID `uploads`), - Another folder (using the parent folder's ID). When a folder is successfully created, the endpoint returns its folder ID, along with other information.",
+    inputSchema: {
+      "type": "object",
+      "properties": {
+        "name": {
+          "type": "string",
+          "description": "The name of the folder."
+        },
+        "parent_folder_id": {
+          "type": "string",
+          "description": "The folder ID of the parent folder. To create a new folder at the top level of a user's\n[projects](https://www.canva.com/help/find-designs-and-folders/), use the ID `root`.\nTo create it in their Uploads folder, use `uploads`."
+        }
+      },
+      "required": [
+        "name",
+        "parent_folder_id"
+      ]
+    },
+    handler: async (params) => text(await apiRequest("POST", "/folders", params)),
+  },
+  {
+    name: "create_reply",
+    description: "<Warning> This API is currently provided as a preview. Be aware of the following: - There might be unannounced breaking changes. - Any breaking changes to preview APIs won't produce a new [API version](https://www.canva.dev/docs/connect/versions/). - Public integrations that use preview APIs will not pass the review process, and can't be made available to all Canva users. </Warning> Creates a reply to a comment or suggestion thread on a design. To reply to an existing thread, you must provide the ID of the thread which is returned when a thread is created, or from the `thread_id` value of an existing reply in the thread. Each thread can have a maximum of 100 replies created for it. For information on comments and how they're used in the Canva UI, see the [Canva Help Center](https://www.canva.com/help/comments/).",
+    inputSchema: {
+      "type": "object",
+      "properties": {
+        "designId": {
+          "type": "string",
+          "description": "The design ID."
+        },
+        "threadId": {
+          "type": "string",
+          "description": "The ID of the thread."
+        },
+        "message_plaintext": {
+          "type": "string",
+          "description": "The comment message of the reply in plaintext. This is the reply comment shown in the Canva UI.\n\nYou can also mention users in your message by specifying their User ID and Team ID\nusing the format `[user_id:team_id]`."
+        }
+      },
+      "required": [
+        "designId",
+        "threadId",
+        "message_plaintext"
+      ]
+    },
+    handler: async (params) => text(await apiRequest("POST", "/designs/{designId}/comments/{threadId}/replies", params)),
+  },
+  {
+    name: "create_thread",
+    description: "<Warning> This API is currently provided as a preview. Be aware of the following: - There might be unannounced breaking changes. - Any breaking changes to preview APIs won't produce a new [API version](https://www.canva.dev/docs/connect/versions/). - Public integrations that use preview APIs will not pass the review process, and can't be made available to all Canva users. </Warning> Creates a new comment thread on a design. For information on comments and how they're used in the Canva UI, see the [Canva Help Center](https://www.canva.com/help/comments/).",
+    inputSchema: {
+      "type": "object",
+      "properties": {
+        "designId": {
+          "type": "string",
+          "description": "The design ID."
+        },
+        "message_plaintext": {
+          "type": "string",
+          "description": "The comment message in plaintext. This is the comment body shown in the Canva UI.\n\nYou can also mention users in your message by specifying their User ID and Team ID\nusing the format `[user_id:team_id]`. If the `assignee_id` parameter is specified, you\nmust mention the assignee in the message."
+        },
+        "assignee_id": {
+          "type": "string",
+          "description": "Lets you assign the comment to a Canva user using their User ID. You _must_ mention the\nassigned user in the `message`."
+        }
+      },
+      "required": [
+        "designId",
+        "message_plaintext"
+      ]
+    },
+    handler: async (params) => text(await apiRequest("POST", "/designs/{designId}/comments", params)),
+  },
+  {
+    name: "create_url_asset_upload_job",
+    description: "<Warning> This API is currently provided as a preview. Be aware of the following: - There might be unannounced breaking changes. - Any breaking changes to preview APIs won't produce a new [API version](https://www.canva.dev/docs/connect/versions/). - Public integrations that use preview APIs will not pass the review process, and can't be made available to all Canva users. </Warning> Starts a new [asynchronous job](https://www.canva.dev/docs/connect/api-requests-responses/#asynchronous-job-endpoints) to upload an asset from a URL to the user's content library. Supported file types for assets are listed in the [Assets API overview](https://www.canva.dev/docs/connect/api-reference/assets/). <Note> Uploading a video asset from a URL is limited to a maximum 100MB file size. For importing larger video files, use the [Create asset upload job API](https://www.canva.dev/docs/connect/api-reference/assets/create-asset-upload-job/). </Note> <Note> For more information on the workflow for using asynchronous jobs, see [API requests and responses](https://www.canva.dev/docs/connect/api-requests-responses/#asynchronous-job-endpoints). You can check the status and get the results of asset upload jobs created with this API using the [Get asset upload job via URL API](https://www.canva.dev/docs/connect/api-reference/assets/get-url-asset-upload-job/). </Note>",
+    inputSchema: {
+      "type": "object",
+      "properties": {
+        "name": {
+          "type": "string",
+          "description": "A name for the asset."
+        },
+        "url": {
+          "type": "string",
+          "description": "The URL of the file to import. This URL must be accessible from the internet and be publicly available."
+        }
+      },
+      "required": [
+        "name",
+        "url"
+      ]
+    },
+    handler: async (params) => text(await apiRequest("POST", "/url-asset-uploads", params)),
+  },
+  {
+    name: "create_url_import_job",
+    description: "Starts a new [asynchronous job](https://www.canva.dev/docs/connect/api-requests-responses/#asynchronous-job-endpoints) to import an external file from a URL as a new design in Canva. Supported file types for imports are listed in [Design imports overview](https://www.canva.dev/docs/connect/api-reference/design-imports/#supported-file-types). <Note> For more information on the workflow for using asynchronous jobs, see [API requests and responses](https://www.canva.dev/docs/connect/api-requests-responses/#asynchronous-job-endpoints). You can check the status and get the results of design import jobs created with this API using the [Get URL import job API](https://www.canva.dev/docs/connect/api-reference/design-imports/get-url-import-job/). </Note>",
+    inputSchema: {
+      "type": "object",
+      "properties": {
+        "title": {
+          "type": "string",
+          "description": "A title for the design."
+        },
+        "url": {
+          "type": "string",
+          "description": "The URL of the file to import. This URL must be accessible from the internet and be publicly available."
+        },
+        "mime_type": {
+          "type": "string",
+          "description": "The MIME type of the file being imported. If not provided, Canva attempts to automatically detect the type of the file."
+        }
+      },
+      "required": [
+        "title",
+        "url"
+      ]
+    },
+    handler: async (params) => text(await apiRequest("POST", "/url-imports", params)),
+  },
+  {
+    name: "move_folder_item",
+    description: "Moves an item to another folder. You must specify the folder ID of the destination folder, as well as the ID of the item you want to move. NOTE: In some situations, a single item can exist in multiple folders. If you attempt to move an item that exists in multiple folders, the API returns an `item_in_multiple_folders` error. In this case, you must use the Canva UI to move the item to another folder.",
+    inputSchema: {
+      "type": "object",
+      "properties": {
+        "to_folder_id": {
+          "type": "string",
+          "description": "The ID of the folder you want to move the item to (the destination folder).\nIf you want to move the item to the top level of a Canva user's\n[projects](https://www.canva.com/help/find-designs-and-folders/), use the ID `root`."
+        },
+        "item_id": {
+          "type": "string",
+          "description": "The ID of the item you want to move. Currently, video assets are not supported."
+        }
+      },
+      "required": [
+        "item_id",
+        "to_folder_id"
+      ]
+    },
+    handler: async (params) => text(await apiRequest("POST", "/folders/move", params)),
+  },
+  {
+    name: "update_asset",
+    description: "You can update the name and tags of an asset by specifying its `assetId`. Updating the tags replaces all existing tags of the asset.",
+    inputSchema: {
+      "type": "object",
+      "properties": {
+        "assetId": {
+          "type": "string",
+          "description": "The ID of the asset."
+        },
+        "name": {
+          "type": "string",
+          "description": "The name of the asset. This is shown in the Canva UI.\nWhen this field is undefined or empty, nothing is updated."
+        },
+        "tags": {
+          "type": "array",
+          "description": "The replacement tags for the asset.\nWhen this field is undefined, nothing is updated."
+        }
+      },
+      "required": [
+        "assetId"
+      ]
+    },
+    handler: async (params) => text(await apiRequest("PATCH", "/assets/{assetId}", params)),
+  },
+  {
+    name: "update_folder",
+    description: "Updates a folder's details using its `folderID`. Currently, you can only update a folder's name.",
+    inputSchema: {
+      "type": "object",
+      "properties": {
+        "folderId": {
+          "type": "string",
+          "description": "The folder ID."
+        },
+        "name": {
+          "type": "string",
+          "description": "The folder name, as shown in the Canva UI."
+        }
+      },
+      "required": [
+        "folderId",
+        "name"
+      ]
+    },
+    handler: async (params) => text(await apiRequest("PATCH", "/folders/{folderId}", params)),
+  },
+  {
+    name: "delete_asset",
+    description: "You can delete an asset by specifying its `assetId`. This operation mirrors the behavior in the Canva UI. Deleting an item moves it to the trash. Deleting an asset doesn't remove it from designs that already use it.",
+    inputSchema: {
+      "type": "object",
+      "properties": {
+        "assetId": {
+          "type": "string",
+          "description": "The ID of the asset."
+        }
+      },
+      "required": [
+        "assetId"
+      ]
+    },
+    handler: async (params) => text(await apiRequest("DELETE", "/assets/{assetId}", params)),
+  },
+  {
+    name: "delete_folder",
+    description: "Deletes a folder with the specified `folderID`. Deleting a folder moves the user's content in the folder to the [Trash](https://www.canva.com/help/deleted-designs/) and content owned by other users is moved to the top level of the owner's [projects](https://www.canva.com/help/find-designs-and-folders/).",
+    inputSchema: {
+      "type": "object",
+      "properties": {
+        "folderId": {
+          "type": "string",
+          "description": "The folder ID."
+        }
+      },
+      "required": [
+        "folderId"
+      ]
+    },
+    handler: async (params) => text(await apiRequest("DELETE", "/folders/{folderId}", params)),
+  },
+  {
+    name: 'create_design_from_template',
+    description: "Creates a new Canva design from a brand template. Sends POST /designs with brand_template_id (Canva may require this field alongside title and optional asset_id). If the API rejects the body, use autofill_brand_template_and_wait with template data instead. Requires brand_template_id from list_brand_templates.",
+    inputSchema: {
+      type: 'object',
+      properties: {
+        brand_template_id: { type: 'string', description: 'Brand template ID from list_brand_templates.' },
+        title: { type: 'string', description: 'Design title.' },
+        asset_id: { type: 'string', description: 'Optional image asset_id to include.' },
+      },
+      required: ['brand_template_id'],
+    },
+    handler: async ({ brand_template_id, title, asset_id }) => {
+      const body = { brand_template_id, title, asset_id };
+      return text(await apiRequest('POST', '/designs', body));
+    },
+  },
+  {
+    name: 'export_design_and_wait',
+    description: "Exports a Canva design to PDF, PNG, JPG, GIF, PPTX, or MP4 and polls GET /exports/{exportId} until the job completes, returning download URLs. Use instead of create_design_export_job when you need the file URL without manual polling.",
+    inputSchema: {
+      type: 'object',
+      properties: {
+        design_id: { type: 'string', description: 'Design ID to export.' },
+        format: {
+          type: 'string',
+          description: 'Export format.',
+          enum: ['pdf', 'png', 'jpg', 'gif', 'pptx', 'mp4'],
+        },
+        pages: {
+          type: 'array',
+          items: { type: 'number' },
+          description: 'Optional 1-based page indices to export.',
+        },
+      },
+      required: ['design_id'],
+    },
+    handler: async (params) => {
+      const design_id = params.design_id;
+      const fmt = params.format || 'pdf';
+      const format = { type: fmt };
+      if (params.pages?.length) format.pages = params.pages;
+      const body = { design_id, format };
+      const created = await apiRequest('POST', '/exports', body);
+      const exportId = created?.job?.id;
+      if (!exportId) return text(created);
+      const final = await pollJob(() => apiRequest('GET', '/exports/{exportId}', { exportId }));
+      return text(final);
+    },
+  },
+  {
+    name: 'list_all_designs',
+    description: "Lists all designs in the user's Canva account using continuation tokens until exhausted. Optional query, ownership filter, page size.",
+    inputSchema: {
+      type: 'object',
+      properties: {
+        query: { type: 'string', description: 'Optional search query.' },
+        ownership: { type: 'string', description: 'owned | shared | any', enum: ['owned', 'shared', 'any'] },
+        page_size: { type: 'number', description: 'Items per request (API limit applies).' },
+        sort_by: { type: 'string', description: 'Optional sort (e.g. relevance).' },
+      },
+      required: [],
+    },
+    handler: async (params) => {
+      const all = [];
+      let continuation;
+      do {
+        const q = { continuation };
+        if (params.query != null && params.query !== '') q.query = params.query;
+        if (params.ownership != null && params.ownership !== '') q.ownership = params.ownership;
+        if (params.sort_by != null && params.sort_by !== '') q.sort_by = params.sort_by;
+        if (params.page_size != null) q.limit = params.page_size;
+        const page = await apiRequest('GET', '/designs', q);
+        const items = page?.items || [];
+        all.push(...items);
+        continuation = page?.continuation;
+      } while (continuation);
+      return text({ items: all, count: all.length });
+    },
+  },
+  {
+    name: 'get_design_with_pages',
+    description: "Returns design metadata from GET /designs/{designId} and all pages from GET /designs/{designId}/pages (paginated via offset/limit).",
+    inputSchema: {
+      type: 'object',
+      properties: { design_id: { type: 'string', description: 'Design ID.' } },
+      required: ['design_id'],
+    },
+    handler: async ({ design_id }) => {
+      const design = await apiRequest('GET', '/designs/{designId}', { designId: design_id });
+      const pages = [];
+      let offset = 1;
+      const limit = 200;
+      while (true) {
+        const chunk = await apiRequest('GET', '/designs/{designId}/pages', {
+          designId: design_id,
+          offset,
+          limit,
+        });
+        const items = chunk?.items || [];
+        pages.push(...items);
+        if (items.length < limit) break;
+        offset += limit;
+      }
+      return text({ design, pages });
+    },
+  },
+  {
+    name: 'duplicate_design',
+    description: "Creates a copy of a design by posting to POST /designs with source_design_id and title. If the API shape differs, use create_design_resize_job or the Canva UI to duplicate.",
+    inputSchema: {
+      type: 'object',
+      properties: {
+        design_id: { type: 'string', description: 'Source design ID.' },
+        new_title: { type: 'string', description: 'Title for the duplicate.' },
+      },
+      required: ['design_id', 'new_title'],
+    },
+    handler: async ({ design_id, new_title }) =>
+      text(
+        await apiRequest('POST', '/designs', {
+          title: new_title,
+          source_design_id: design_id,
+        })
+      ),
+  },
+  {
+    name: 'upload_asset_and_wait',
+    description: "Uploads an asset from a URL via POST /url-asset-uploads, then polls until the job completes. Use before create_design_from_template for custom images.",
+    inputSchema: {
+      type: 'object',
+      properties: {
+        asset_url: { type: 'string', description: 'Public URL of the image or video.' },
+        asset_name: { type: 'string', description: 'Display name for the asset.' },
+      },
+      required: ['asset_url', 'asset_name'],
+    },
+    handler: async ({ asset_url, asset_name }) => {
+      const body = { url: asset_url, name: asset_name };
+      const created = await apiRequest('POST', '/url-asset-uploads', body);
+      const jobId = created?.job?.id;
+      if (!jobId) return text(created);
+      const final = await pollJob(() => apiRequest('GET', '/url-asset-uploads/{jobId}', { jobId }));
+      return text(final);
+    },
+  },
+  {
+    name: 'list_all_assets',
+    description: "Connect API lists uploads as folder items: paginates GET /folders/{folderId}/items for the uploads folder (folder_id default uploads) with item_types image. There is no GET /assets list in the OpenAPI spec.",
+    inputSchema: {
+      type: 'object',
+      properties: {
+        folder_id: { type: 'string', description: 'Defaults to uploads — the user uploads library.' },
+        query: { type: 'string', description: 'Passed through if the API supports search on folder items.' },
+        page_size: { type: 'number' },
+        tags: { type: 'array', items: { type: 'string' }, description: 'Reserved; folder list may not support tag filter.' },
+      },
+      required: [],
+    },
+    handler: async (params) => {
+      const folderId = params.folder_id || 'uploads';
+      const all = [];
+      let continuation;
+      do {
+        const q = { folderId, continuation, item_types: 'image' };
+        if (params.query) q.query = params.query;
+        if (params.page_size != null) q.limit = params.page_size;
+        const page = await apiRequest('GET', '/folders/{folderId}/items', q);
+        const items = page?.items || [];
+        all.push(...items);
+        continuation = page?.continuation;
+      } while (continuation);
+      return text({ items: all, count: all.length, folder_id: folderId });
+    },
+  },
+  {
+    name: 'get_folder_contents_full',
+    description: "Lists all items in a folder via GET /folders/{folderId}/items with continuation. item_type filters map to item_types when set.",
+    inputSchema: {
+      type: 'object',
+      properties: {
+        folder_id: { type: 'string' },
+        item_type: {
+          type: 'string',
+          description: 'design | folder | image | all',
+          enum: ['design', 'folder', 'image', 'all'],
+        },
+        page_size: { type: 'number' },
+      },
+      required: ['folder_id'],
+    },
+    handler: async ({ folder_id, item_type, page_size }) => {
+      const all = [];
+      let continuation;
+      const folderId = folder_id;
+      do {
+        const q = { folderId, continuation };
+        if (page_size != null) q.limit = page_size;
+        if (item_type && item_type !== 'all') {
+          const t = item_type === 'asset' ? 'image' : item_type;
+          q.item_types = t;
+        }
+        const page = await apiRequest('GET', '/folders/{folderId}/items', q);
+        const items = page?.items || [];
+        all.push(...items);
+        continuation = page?.continuation;
+      } while (continuation);
+      return text({ items: all, count: all.length });
+    },
+  },
+  {
+    name: 'create_project_folder',
+    description: "Creates a folder via POST /folders. Use parent_folder_id or parent_folder_id root/uploads; omit for top-level by passing parent_folder_id root.",
+    inputSchema: {
+      type: 'object',
+      properties: {
+        name: { type: 'string', description: 'Folder name.' },
+        parent_folder_id: {
+          type: 'string',
+          description: 'Parent folder ID, or root | uploads for special roots.',
+        },
+      },
+      required: ['name'],
+    },
+    handler: async ({ name, parent_folder_id }) => {
+      const body = { name, parent_folder_id: parent_folder_id || 'root' };
+      return text(await apiRequest('POST', '/folders', body));
+    },
+  },
+  {
+    name: 'move_design_to_folder',
+    description: "Moves a design or asset using POST /folders/move (to_folder_id + item_id). item_type is accepted for documentation; API uses item_id only.",
+    inputSchema: {
+      type: 'object',
+      properties: {
+        folder_id: { type: 'string', description: 'Destination folder ID (or root).' },
+        item_id: { type: 'string', description: 'Design or asset ID to move.' },
+        item_type: { type: 'string', description: 'design | asset (informational).' },
+      },
+      required: ['folder_id', 'item_id'],
+    },
+    handler: async ({ folder_id, item_id }) =>
+      text(await apiRequest('POST', '/folders/move', { to_folder_id: folder_id, item_id })),
+  },
+  {
+    name: 'list_brand_templates',
+    description: "Lists all brand templates with automatic continuation pagination. Use before create_design_from_template or autofill_brand_template_and_wait.",
+    inputSchema: {
+      type: 'object',
+      properties: {
+        query: { type: 'string' },
+        page_size: { type: 'number', description: 'Mapped to limit per request when applicable.' },
+      },
+      required: [],
+    },
+    handler: async (params) => {
+      const all = [];
+      let continuation;
+      do {
+        const q = { continuation };
+        if (params.query) q.query = params.query;
+        if (params.page_size != null) q.limit = params.page_size;
+        const page = await apiRequest('GET', '/brand-templates', q);
+        const items = page?.items || [];
+        all.push(...items);
+        continuation = page?.continuation;
+      } while (continuation);
+      return text({ items: all, count: all.length });
+    },
+  },
+  {
+    name: 'get_brand_template_dataset',
+    description: "Returns GET /brand-templates/{brandTemplateId}/dataset — autofill field definitions for a template.",
+    inputSchema: {
+      type: 'object',
+      properties: { brand_template_id: { type: 'string' } },
+      required: ['brand_template_id'],
+    },
+    handler: async ({ brand_template_id }) =>
+      text(
+        await apiRequest('GET', '/brand-templates/{brandTemplateId}/dataset', {
+          brandTemplateId: brand_template_id,
+        })
+      ),
+  },
+  {
+    name: 'autofill_brand_template_and_wait',
+    description: "POST /autofills then polls GET /autofills/{jobId} until success or failure. data maps field names to dataset values (text/image/chart objects).",
+    inputSchema: {
+      type: 'object',
+      properties: {
+        brand_template_id: { type: 'string' },
+        title: { type: 'string' },
+        data: { type: 'object', description: 'Field name → DatasetValue object per Canva API.' },
+      },
+      required: ['brand_template_id', 'data'],
+    },
+    handler: async ({ brand_template_id, title, data }) => {
+      const body = { brand_template_id, data };
+      if (title) body.title = title;
+      const created = await apiRequest('POST', '/autofills', body);
+      const jobId = created?.job?.id;
+      if (!jobId) return text(created);
+      const final = await pollJob(() => apiRequest('GET', '/autofills/{jobId}', { jobId }));
+      return text(final);
+    },
+  },
+  {
+    name: 'list_all_design_comments',
+    description: "Attempts GET /designs/{designId}/comments with continuation pagination. Note: the shipped OpenAPI spec may only define POST for this path; if the API returns 404, list threads via webhooks or known thread IDs and get_thread.",
+    inputSchema: {
+      type: 'object',
+      properties: { design_id: { type: 'string' } },
+      required: ['design_id'],
+    },
+    handler: async ({ design_id }) => {
+      const all = [];
+      let continuation;
+      do {
+        const page = await apiRequest('GET', '/designs/{designId}/comments', {
+          designId: design_id,
+          continuation,
+        });
+        const items = page?.items || page?.comments || page?.threads || [];
+        if (Array.isArray(items)) all.push(...items);
+        continuation = page?.continuation;
+        if (!continuation && !Array.isArray(items)) break;
+      } while (continuation);
+      return text({ items: all, count: all.length });
+    },
+  },
+  {
+    name: 'resolve_comment',
+    description: "PATCH /designs/{designId}/comments/{commentId} marking resolved. comment_id is the thread or comment ID. Preview APIs may change; verify against current Canva docs if this fails.",
+    inputSchema: {
+      type: 'object',
+      properties: {
+        design_id: { type: 'string' },
+        comment_id: { type: 'string', description: 'Thread or comment ID.' },
+      },
+      required: ['design_id', 'comment_id'],
+    },
+    handler: async ({ design_id, comment_id }) =>
+      text(
+        await apiRequest(
+          'PATCH',
+          '/designs/{designId}/comments/{commentId}',
+          { designId: design_id, commentId: comment_id },
+          { rawBody: { resolved: true } }
+        )
+      ),
+  },
+  {
+    name: 'get_current_user_profile',
+    description: "GET /users/me — authenticated user's profile (user id, team, display context).",
+    inputSchema: { type: 'object', properties: {}, required: [] },
+    handler: async () => text(await apiRequest('GET', '/users/me', {})),
+  },
+
+];
+
+export const tools = generatedTools;