@opencx/mcp 1.15.39 → 1.15.41

package/dist/tools/help-center.js

@@ -7,108 +7,618 @@ export function registerHelpCenterTools(server, client) {
         const data = (await client.GET('/hc')).data;
         return jsonContent(data);
     });
-    server.registerTool('export_help_center_content', {
-        description: 'Export the full content tree (categories and articles) of a help center. Returns all published content in a structured format.',
+    server.registerTool('list_help_center_media', {
+        description: 'List all media files (images, documents) uploaded to a help center.',
         inputSchema: {
             help_center_id: z.string().describe('The help center ID'),
         },
     }, async ({ help_center_id }) => {
-        const data = (await client.GET('/hc/{id}/export', {
+        const data = (await client.GET('/hc/{id}/media', {
             params: { path: { id: help_center_id } },
         })).data;
         return jsonContent(data);
     });
-    server.registerTool('sync_help_center_content', {
-        description: 'Replace the help center content tree atomically. Use export_help_center_content first to see the current structure.',
-        inputSchema: {
-            help_center_id: z.string().describe('The help center ID'),
-            categories: z
-                .array(z.object({
-                slug: z.string().describe('URL-friendly identifier for the category'),
-                title: z.string().describe('Display title of the category'),
-                description: z.string().optional().describe('Category description'),
-                icon: z.string().optional().describe('Icon identifier'),
-                articles: z
-                    .array(z.object({
-                    slug: z.string().describe('URL-friendly identifier for the article'),
-                    title: z.string().describe('Article title'),
-                    content: z.string().describe('Article content in markdown'),
-                    status: z
-                        .enum(['published', 'draft'])
-                        .optional()
-                        .describe('Publication status'),
-                }))
-                    .optional()
-                    .describe('Articles in this category'),
-                subcategories: z
-                    .array(z.object({
-                    slug: z.string(),
-                    title: z.string(),
-                    description: z.string().optional(),
-                    articles: z
-                        .array(z.object({
-                        slug: z.string(),
-                        title: z.string(),
-                        content: z.string(),
-                        status: z.enum(['published', 'draft']).optional(),
-                    }))
-                        .optional(),
-                }))
-                    .optional()
-                    .describe('Nested subcategories'),
+    server.registerTool('delete_help_center_media', {
+        description: 'Delete a media file from a help center.',
+        inputSchema: {
+            help_center_id: z.string().describe('The help center ID'),
+            media_id: z.string().describe('The media file ID to delete'),
+        },
+    }, async ({ help_center_id, media_id }) => {
+        const data = (await client.DELETE('/hc/{id}/media/{mediaId}', {
+            params: { path: { id: help_center_id, mediaId: media_id } },
+        })).data;
+        return jsonContent(data);
+    });
+    registerHelpCenterSiteTools(server, client);
+    registerHelpCenterGlossaryTools(server, client);
+    registerHelpCenterArticleTools(server, client);
+    registerHelpCenterTopicTools(server, client);
+    registerHelpCenterStructureTools(server, client);
+}
+/** One article at a time. */
+function registerHelpCenterArticleTools(server, client) {
+    server.registerTool('list_help_center_articles', {
+        description: 'List the articles in a help center, with their topic and publish state. Start here to find the entity id of the article you want to read or change.',
+        inputSchema: {
+            help_center_id: z.string().describe('The help center ID'),
+            language_code: z
+                .string()
+                .optional()
+                .describe("Which language to list; defaults to the help center's primary language."),
+        },
+    }, async ({ help_center_id, language_code }) => {
+        const data = (await client.GET('/hc/{helpCenterId}/articles', {
+            params: {
+                path: { helpCenterId: help_center_id },
+                query: language_code ? { language_code } : {},
+            },
+        })).data;
+        return jsonContent(data);
+    });
+    server.registerTool('get_help_center_article', {
+        description: 'Read one article: its entity, the published version, the latest version, and the locale being asked for. Read this before any update so the content you send back is built on what is actually stored.',
+        inputSchema: {
+            help_center_id: z.string().describe('The help center ID'),
+            entity_id: z.string().describe('The article entity ID'),
+            language_code: z
+                .string()
+                .optional()
+                .describe("Which language to read; defaults to the help center's primary language."),
+        },
+    }, async ({ help_center_id, entity_id, language_code }) => {
+        const data = (await client.GET('/hc/{helpCenterId}/articles/{entityId}', {
+            params: {
+                path: { helpCenterId: help_center_id, entityId: entity_id },
+                query: language_code ? { language_code } : {},
+            },
+        })).data;
+        return jsonContent(data);
+    });
+    server.registerTool('list_help_center_article_versions', {
+        description: 'List the saved versions of an article in one language, newest first. Use it to see what changed and when, or to find a version to publish.',
+        inputSchema: {
+            help_center_id: z.string().describe('The help center ID'),
+            entity_id: z.string().describe('The article entity ID'),
+            language_code: z.string().optional().describe('Which language to list versions for.'),
+        },
+    }, async ({ help_center_id, entity_id, language_code }) => {
+        const data = (await client.GET('/hc/{helpCenterId}/articles/{entityId}/versions', {
+            params: {
+                path: { helpCenterId: help_center_id, entityId: entity_id },
+                query: language_code ? { language_code } : {},
+            },
+        })).data;
+        return jsonContent(data);
+    });
+    server.registerTool('create_help_center_article', {
+        description: 'Create an article in a topic. It is created unpublished: nothing reaches readers until someone publishes it. Content is markdown.',
+        inputSchema: {
+            help_center_id: z.string().describe('The help center ID'),
+            category_entity_id: z.string().describe('The topic to create the article in'),
+            title: z.string().describe('The article title'),
+            slug: z.string().optional().describe('URL path; derived from the title when omitted.'),
+            content_markdown: z.string().optional().describe('The article body, in markdown.'),
+            meta_title: z.string().optional().describe('Title tag for search engines.'),
+            meta_description: z.string().optional().describe('Meta description for search engines.'),
+            language_code: z
+                .string()
+                .optional()
+                .describe("The language the article is written in; defaults to the help center's primary language."),
+        },
+    }, async ({ help_center_id, ...body }) => {
+        const data = (await client.POST('/hc/{helpCenterId}/articles', {
+            params: { path: { helpCenterId: help_center_id } },
+            body,
+        })).data;
+        return jsonContent(data);
+    });
+    server.registerTool('update_help_center_article', {
+        description: "Replace an article's content with a new saved version. Read the article first with get_help_center_article and send the complete body back, not just the part you changed — this overwrites. The new version is unpublished until someone publishes it.",
+        inputSchema: {
+            help_center_id: z.string().describe('The help center ID'),
+            entity_id: z.string().describe('The article entity ID'),
+            title: z.string().describe('The article title'),
+            content_markdown: z.string().optional().describe('The complete article body, in markdown.'),
+            meta_title: z.string().optional().describe('Title tag for search engines.'),
+            meta_description: z.string().optional().describe('Meta description for search engines.'),
+            language_code: z.string().optional().describe('Which language version to write.'),
+        },
+    }, async ({ help_center_id, entity_id, ...body }) => {
+        const data = (await client.PUT('/hc/{helpCenterId}/articles/{entityId}', {
+            params: { path: { helpCenterId: help_center_id, entityId: entity_id } },
+            body,
+        })).data;
+        return jsonContent(data);
+    });
+    server.registerTool('publish_help_center_article', {
+        description: 'Publish an article, so readers can see it. Name a language to publish only that one; leave it out to publish every language the article has. ONLY call this when the person has asked for the article to go live — never as the tail end of an edit.',
+        inputSchema: {
+            help_center_id: z.string().describe('The help center ID'),
+            entity_id: z.string().describe('The article entity ID'),
+            language_code: z
+                .string()
+                .optional()
+                .describe('Publish only this language; omit to publish every language.'),
+            version_id: z
+                .string()
+                .optional()
+                .describe('Publish this specific version; defaults to the latest.'),
+        },
+    }, async ({ help_center_id, entity_id, language_code, version_id }) => {
+        // One language and all languages are two routes; which one the person
+        // meant is the presence of a language, not a second tool to choose from.
+        if (language_code) {
+            const data = (await client.POST('/hc/{helpCenterId}/articles/{entityId}/locales/{languageCode}/publish', {
+                params: {
+                    path: {
+                        helpCenterId: help_center_id,
+                        entityId: entity_id,
+                        languageCode: language_code,
+                    },
+                },
+                body: version_id ? { locale_version_id: version_id } : {},
+            })).data;
+            return jsonContent(data);
+        }
+        const data = (await client.POST('/hc/{helpCenterId}/articles/{entityId}/publish', {
+            params: { path: { helpCenterId: help_center_id, entityId: entity_id } },
+            body: version_id ? { source_version_id: version_id } : {},
+        })).data;
+        return jsonContent(data);
+    });
+    server.registerTool('unpublish_help_center_article', {
+        description: 'Take an article off the live help center, in one language or in all of them. The content and its history are kept. ONLY on an explicit request.',
+        inputSchema: {
+            help_center_id: z.string().describe('The help center ID'),
+            entity_id: z.string().describe('The article entity ID'),
+            language_code: z
+                .string()
+                .optional()
+                .describe('Unpublish only this language; omit to unpublish every language.'),
+        },
+    }, async ({ help_center_id, entity_id, language_code }) => {
+        const data = (await client.POST('/hc/{helpCenterId}/articles/{entityId}/unpublish', {
+            params: { path: { helpCenterId: help_center_id, entityId: entity_id } },
+            body: language_code ? { language_code } : {},
+        })).data;
+        return jsonContent(data);
+    });
+    server.registerTool('delete_help_center_article', {
+        description: 'Delete an article. ONLY on an explicit request to delete — never to tidy up after another change. Ask first.',
+        inputSchema: {
+            help_center_id: z.string().describe('The help center ID'),
+            entity_id: z.string().describe('The article entity ID'),
+        },
+    }, async ({ help_center_id, entity_id }) => {
+        const data = (await client.DELETE('/hc/{helpCenterId}/articles/{entityId}', {
+            params: { path: { helpCenterId: help_center_id, entityId: entity_id } },
+        })).data;
+        return jsonContent(data);
+    });
+    server.registerTool('restore_help_center_article', {
+        description: 'Bring a deleted article back with its content and put it back in the tree. Only works while it is still recoverable.',
+        inputSchema: {
+            help_center_id: z.string().describe('The help center ID'),
+            entity_id: z.string().describe('The article entity ID'),
+        },
+    }, async ({ help_center_id, entity_id }) => {
+        const data = (await client.POST('/hc/{helpCenterId}/articles/{entityId}/restore-deleted', {
+            params: { path: { helpCenterId: help_center_id, entityId: entity_id } },
+        })).data;
+        return jsonContent(data);
+    });
+    server.registerTool('get_help_center_article_language_states', {
+        description: 'For each language of an article: whether it is live, whether it has changes nobody has published, and whether its translation is behind the source. Read this before publishing to know what will actually change.',
+        inputSchema: {
+            help_center_id: z.string().describe('The help center ID'),
+            entity_id: z.string().describe('The article entity ID'),
+        },
+    }, async ({ help_center_id, entity_id }) => {
+        const data = (await client.GET('/hc/{helpCenterId}/articles/{entityId}/language-states', {
+            params: { path: { helpCenterId: help_center_id, entityId: entity_id } },
+        })).data;
+        return jsonContent(data);
+    });
+    server.registerTool('retranslate_help_center_article', {
+        description: 'Translate an article again from its source language. Name a language to redo only that one; leave it out to redo every other language. This OVERWRITES what is there, including a translation someone wrote by hand. ONLY on an explicit request.',
+        inputSchema: {
+            help_center_id: z.string().describe('The help center ID'),
+            entity_id: z.string().describe('The article entity ID'),
+            language_code: z
+                .string()
+                .optional()
+                .describe('Redo only this language; omit to redo every other language.'),
+        },
+    }, async ({ help_center_id, entity_id, language_code }) => {
+        const path = { helpCenterId: help_center_id, entityId: entity_id };
+        const data = language_code
+            ? (await client.POST('/hc/{helpCenterId}/articles/{entityId}/retranslate', {
+                params: { path },
+                body: { language_code },
+            })).data
+            : (await client.POST('/hc/{helpCenterId}/articles/{entityId}/retranslate-all', {
+                params: { path },
+            })).data;
+        return jsonContent(data);
+    });
+}
+/** Topics are the folders of a help center; every article lives in one. */
+function registerHelpCenterTopicTools(server, client) {
+    server.registerTool('list_help_center_topics', {
+        description: 'List the topics of a help center. Topics can nest, so each one carries its parent.',
+        inputSchema: {
+            help_center_id: z.string().describe('The help center ID'),
+            language_code: z
+                .string()
+                .optional()
+                .describe("Which language to list; defaults to the help center's primary language."),
+        },
+    }, async ({ help_center_id, language_code }) => {
+        const data = (await client.GET('/hc/{helpCenterId}/categories', {
+            params: {
+                path: { helpCenterId: help_center_id },
+                query: language_code ? { language_code } : {},
+            },
+        })).data;
+        return jsonContent(data);
+    });
+    server.registerTool('get_help_center_topic', {
+        description: 'Read one topic and the names it has in each language.',
+        inputSchema: {
+            help_center_id: z.string().describe('The help center ID'),
+            category_entity_id: z.string().describe('The topic entity ID'),
+            language_code: z.string().optional().describe('Which language to read.'),
+        },
+    }, async ({ help_center_id, category_entity_id, language_code }) => {
+        const data = (await client.GET('/hc/{helpCenterId}/categories/{categoryEntityId}', {
+            params: {
+                path: { helpCenterId: help_center_id, categoryEntityId: category_entity_id },
+                query: language_code ? { language_code } : {},
+            },
+        })).data;
+        return jsonContent(data);
+    });
+    server.registerTool('create_help_center_topic', {
+        description: 'Create a topic, at the top level or inside another topic.',
+        inputSchema: {
+            help_center_id: z.string().describe('The help center ID'),
+            name: z.string().describe('The topic name'),
+            slug: z.string().optional().describe('URL path; derived from the name when omitted.'),
+            description: z
+                .string()
+                .optional()
+                .describe('Short blurb shown under the topic name on the help-center home grid.'),
+            icon: z
+                .string()
+                .optional()
+                .describe("Lucide icon name in kebab-case (e.g. 'folder', 'credit-card' — see lucide.dev/icons). An unknown name renders no icon."),
+            parent_id: z
+                .string()
+                .nullable()
+                .optional()
+                .describe('Create it inside this topic; omit or null for a top-level topic.'),
+        },
+    }, async ({ help_center_id, ...body }) => {
+        const data = (await client.POST('/hc/{helpCenterId}/categories', {
+            params: { path: { helpCenterId: help_center_id } },
+            body,
+        })).data;
+        return jsonContent(data);
+    });
+    server.registerTool('update_help_center_topic', {
+        description: 'Rename a topic or change its blurb or icon. Omitting the description CLEARS it, so send the current one back if you only mean to change something else. Writing the primary language re-translates the others; writing another language edits that translation only. Use move_help_center_topic to move it.',
+        inputSchema: {
+            help_center_id: z.string().describe('The help center ID'),
+            category_entity_id: z.string().describe('The topic entity ID'),
+            name: z.string().describe('The topic name'),
+            description: z
+                .string()
+                .optional()
+                .describe('Short blurb shown under the topic name. Omitting it CLEARS the stored one.'),
+            icon: z
+                .string()
+                .nullable()
+                .optional()
+                .describe('Lucide icon name in kebab-case; null clears it, omitted leaves it alone.'),
+            language_code: z
+                .string()
+                .optional()
+                .describe("Which language's name and blurb to write; defaults to the help center's primary language."),
+        },
+    }, async ({ help_center_id, category_entity_id, ...body }) => {
+        const data = (await client.PUT('/hc/{helpCenterId}/categories/{categoryEntityId}', {
+            params: {
+                path: { helpCenterId: help_center_id, categoryEntityId: category_entity_id },
+            },
+            body,
+        })).data;
+        return jsonContent(data);
+    });
+    server.registerTool('delete_help_center_topic', {
+        description: 'Delete a topic. Everything inside it — articles and subtopics — is deleted with it unless you name a topic to move them to. ONLY on an explicit request, and say what will go with it before you do.',
+        inputSchema: {
+            help_center_id: z.string().describe('The help center ID'),
+            category_entity_id: z.string().describe('The topic entity ID'),
+            move_contents_to: z
+                .string()
+                .optional()
+                .describe("Move this topic's articles and subtopics under this topic instead of deleting them."),
+        },
+    }, async ({ help_center_id, category_entity_id, move_contents_to }) => {
+        const data = (await client.DELETE('/hc/{helpCenterId}/categories/{categoryEntityId}', {
+            params: {
+                path: { helpCenterId: help_center_id, categoryEntityId: category_entity_id },
+                query: move_contents_to ? { move_contents_to } : {},
+            },
+        })).data;
+        return jsonContent(data);
+    });
+    server.registerTool('restore_help_center_topic', {
+        description: 'Bring a deleted topic back and put it back in the tree. Only works while it is still recoverable.',
+        inputSchema: {
+            help_center_id: z.string().describe('The help center ID'),
+            category_entity_id: z.string().describe('The topic entity ID'),
+        },
+    }, async ({ help_center_id, category_entity_id }) => {
+        const data = (await client.POST('/hc/{helpCenterId}/categories/{categoryEntityId}/restore-deleted', {
+            params: {
+                path: { helpCenterId: help_center_id, categoryEntityId: category_entity_id },
+            },
+        })).data;
+        return jsonContent(data);
+    });
+    server.registerTool('retranslate_help_center_topic', {
+        description: "Translate a topic's name and blurb again. Name a language to redo only that one; leave it out to redo every other language. This OVERWRITES what is there. ONLY on an explicit request.",
+        inputSchema: {
+            help_center_id: z.string().describe('The help center ID'),
+            category_entity_id: z.string().describe('The topic entity ID'),
+            language_code: z
+                .string()
+                .optional()
+                .describe('Redo only this language; omit to redo every other language.'),
+        },
+    }, async ({ help_center_id, category_entity_id, language_code }) => {
+        const path = { helpCenterId: help_center_id, categoryEntityId: category_entity_id };
+        const data = language_code
+            ? (await client.POST('/hc/{helpCenterId}/categories/{categoryEntityId}/retranslate', {
+                params: { path },
+                body: { language_code },
+            })).data
+            : (await client.POST('/hc/{helpCenterId}/categories/{categoryEntityId}/retranslate-all', {
+                params: { path },
+            })).data;
+        return jsonContent(data);
+    });
+}
+/**
+ * The help center itself: how it is branded, what it injects into the page,
+ * and which languages it serves. Not its content — that is the article and
+ * topic tools above.
+ */
+function registerHelpCenterSiteTools(server, client) {
+    server.registerTool('get_help_center', {
+        description: 'Read one help center: name, description, domain, logo, theme, custom CSS and head scripts, sidebar layout, translation prompt, the languages it serves, whether it auto-translates, and the per-language title/description overrides. Read this before changing anything on it.',
+        inputSchema: {
+            help_center_id: z.string().describe('The help center ID'),
+        },
+    }, async ({ help_center_id }) => {
+        const data = (await client.GET('/hc/{id}', { params: { path: { id: help_center_id } } }))
+            .data;
+        return jsonContent(data);
+    });
+    server.registerTool('update_help_center', {
+        description: 'Change the help center itself. Only the fields you send are changed, except localizations, which REPLACE what is stored — read the help center first and send the whole map back. Custom CSS and head scripts run on every page for every reader, so treat them as production changes and say what you are injecting before you do it.',
+        inputSchema: {
+            help_center_id: z.string().describe('The help center ID'),
+            name: z.string().optional().describe('The help center name, in the primary language.'),
+            description: z.string().optional().describe('Tagline shown under the name.'),
+            domain: z
+                .string()
+                .optional()
+                .describe('Custom domain, e.g. help.example.com — no scheme, no path.'),
+            logo_url: z.string().nullable().optional().describe('Logo image URL; null removes it.'),
+            translation_prompt: z
+                .string()
+                .nullable()
+                .optional()
+                .describe('Extra standing instructions for the translator — tone, formality, what never to translate. Applies to translations made from now on; null clears it.'),
+            custom_css: z
+                .string()
+                .nullable()
+                .optional()
+                .describe('CSS injected into every page; null removes it.'),
+            custom_head_scripts: z
+                .string()
+                .nullable()
+                .optional()
+                .describe('HTML injected into <head> on every page — analytics, fonts, verification tags. null removes it.'),
+            sidebar_variant: z
+                .enum(['sidebar', 'floating', 'inset'])
+                .optional()
+                .describe('How the navigation sidebar is laid out.'),
+            localizations: z
+                .record(z.string(), z.object({
+                title: z.string().optional(),
+                description: z.string().nullable().optional(),
             }))
-                .describe('The content tree to sync'),
-        },
-    }, async ({ help_center_id, categories }) => {
-        const mappedCategories = categories.map((cat) => ({
-            name: cat.title,
-            slug: cat.slug,
-            description: cat.description,
-            icon: cat.icon,
-            articles: (cat.articles ?? []).map((a) => ({
-                title: a.title,
-                slug: a.slug,
-                content_markdown: a.content,
-            })),
-            categories: cat.subcategories?.map((sub) => ({
-                name: sub.title,
-                slug: sub.slug,
-                description: sub.description,
-                articles: (sub.articles ?? []).map((a) => ({
-                    title: a.title,
-                    slug: a.slug,
-                    content_markdown: a.content,
-                })),
-            })),
-        }));
-        const data = (await client.POST('/hc/{id}/sync', {
+                .optional()
+                .describe('Per-language site title and description, keyed by language code. REPLACES the stored map: a language you leave out loses its override and falls back to the primary-language name.'),
+        },
+    }, async ({ help_center_id, ...body }) => {
+        const data = (await client.PUT('/hc/{id}', { params: { path: { id: help_center_id } }, body })).data;
+        return jsonContent(data);
+    });
+    server.registerTool('list_help_center_translation_jobs', {
+        description: 'Translations that have not landed: still queued, running, or failed on their last attempt. Read each one’s status — `pending` and `running` are still working, `failed` errored and may be retried. Only an empty list means every language is there. Check it after a publish or a retranslate before telling anyone the article is live everywhere.',
+        inputSchema: {
+            help_center_id: z.string().describe('The help center ID'),
+        },
+    }, async ({ help_center_id }) => {
+        const data = (await client.GET('/hc/{id}/translation-jobs', {
             params: { path: { id: help_center_id } },
-            body: { categories: mappedCategories },
         })).data;
         return jsonContent(data);
     });
-    server.registerTool('list_help_center_media', {
-        description: 'List all media files (images, documents) uploaded to a help center.',
+    server.registerTool('update_help_center_languages', {
+        description: 'Change which languages the help center serves, and whether publishing a source article translates it automatically. enabled_languages REPLACES the list — read it first and send the whole list back; dropping a language stops serving it to readers. The primary language cannot be changed.',
+        inputSchema: {
+            help_center_id: z.string().describe('The help center ID'),
+            enabled_languages: z
+                .array(z.string())
+                .optional()
+                .describe('The complete list of language codes the site is served in.'),
+            auto_translate: z
+                .enum(['on_publish', 'off'])
+                .optional()
+                .describe("'on_publish' translates an article into every other enabled language when its source language is published; 'off' leaves translation to retranslate_help_center_article."),
+        },
+    }, async ({ help_center_id, ...body }) => {
+        const data = (await client.PUT('/hc/{id}/languages', {
+            params: { path: { id: help_center_id } },
+            body,
+        })).data;
+        return jsonContent(data);
+    });
+}
+/** Terms the translator must render exactly as defined, never paraphrased. */
+function registerHelpCenterGlossaryTools(server, client) {
+    server.registerTool('list_help_center_glossary_terms', {
+        description: 'List the translation glossary: terms the translator keeps exactly as defined — product names, feature names, anything that must survive translation unchanged.',
         inputSchema: {
             help_center_id: z.string().describe('The help center ID'),
         },
     }, async ({ help_center_id }) => {
-        const data = (await client.GET('/hc/{id}/media', {
+        const data = (await client.GET('/hc/{id}/glossary', { params: { path: { id: help_center_id } } })).data;
+        return jsonContent(data);
+    });
+    server.registerTool('create_help_center_glossary_term', {
+        description: 'Add a term the translator must keep as defined. It applies to translations made from now on; articles already translated keep their wording until they are retranslated.',
+        inputSchema: {
+            help_center_id: z.string().describe('The help center ID'),
+            term: z.string().describe('The term as it appears in the source language.'),
+            definition: z
+                .string()
+                .describe('What it means, or how it must be rendered in other languages.'),
+        },
+    }, async ({ help_center_id, ...body }) => {
+        const data = (await client.POST('/hc/{id}/glossary', {
             params: { path: { id: help_center_id } },
+            body,
         })).data;
         return jsonContent(data);
     });
-    server.registerTool('delete_help_center_media', {
-        description: 'Delete a media file from a help center.',
+    server.registerTool('import_help_center_glossary_terms', {
+        description: 'Copy the organization-wide translation glossary into this help center in one call. Terms already here are left alone; the answer says how many were added.',
         inputSchema: {
             help_center_id: z.string().describe('The help center ID'),
-            media_id: z.string().describe('The media file ID to delete'),
         },
-    }, async ({ help_center_id, media_id }) => {
-        await client.DELETE('/hc/{id}/media/{mediaId}', {
-            params: { path: { id: help_center_id, mediaId: media_id } },
-        });
-        return { content: [{ type: 'text', text: JSON.stringify({}) }] };
+    }, async ({ help_center_id }) => {
+        const data = (await client.POST('/hc/{id}/glossary/import-from-translation', {
+            params: { path: { id: help_center_id } },
+        })).data;
+        return jsonContent(data);
+    });
+    server.registerTool('update_help_center_glossary_term', {
+        description: 'Change a glossary term or its definition.',
+        inputSchema: {
+            help_center_id: z.string().describe('The help center ID'),
+            term_id: z.string().describe('The glossary term ID'),
+            term: z.string().optional().describe('The new term.'),
+            definition: z.string().optional().describe('The new definition.'),
+        },
+    }, async ({ help_center_id, term_id, ...body }) => {
+        const data = (await client.PUT('/hc/{id}/glossary/{termId}', {
+            params: { path: { id: help_center_id, termId: term_id } },
+            body,
+        })).data;
+        return jsonContent(data);
+    });
+    server.registerTool('delete_help_center_glossary_term', {
+        description: 'Remove a glossary term. Later translations are free to render it however they like.',
+        inputSchema: {
+            help_center_id: z.string().describe('The help center ID'),
+            term_id: z.string().describe('The glossary term ID'),
+        },
+    }, async ({ help_center_id, term_id }) => {
+        const data = (await client.DELETE('/hc/{id}/glossary/{termId}', {
+            params: { path: { id: help_center_id, termId: term_id } },
+        })).data;
+        return jsonContent(data);
+    });
+}
+/**
+ * Where things sit and in what order. Each language has its own tree, so a
+ * move in one language leaves the others where they are.
+ */
+function registerHelpCenterStructureTools(server, client) {
+    server.registerTool('get_help_center_tree', {
+        description: 'The whole help center for one language: nested topics with their articles, in the order readers see them. Each article says whether it has a version, a published version and an unsaved draft. Read this before moving or reordering anything.',
+        inputSchema: {
+            help_center_id: z.string().describe('The help center ID'),
+            language_code: z.string().describe('Which language tree to read.'),
+        },
+    }, async ({ help_center_id, language_code }) => {
+        const data = (await client.GET('/hc/{helpCenterId}/structure/tree', {
+            params: { path: { helpCenterId: help_center_id }, query: { language_code } },
+        })).data;
+        return jsonContent(data);
+    });
+    server.registerTool('move_help_center_article', {
+        description: 'Put an article in a topic, at a given place in its list. Affects only the named language; the other languages keep their own order.',
+        inputSchema: {
+            help_center_id: z.string().describe('The help center ID'),
+            article_entity_id: z.string().describe('The article entity ID'),
+            category_entity_id: z.string().describe('The topic to put it in'),
+            language_code: z.string().describe("Which language's tree to change."),
+            position: z.number().int().min(0).describe('Where in the topic it goes; 0 is first.'),
+        },
+    }, async ({ help_center_id, ...body }) => {
+        const data = (await client.POST('/hc/{helpCenterId}/structure/move-article', {
+            params: { path: { helpCenterId: help_center_id } },
+            body,
+        })).data;
+        return jsonContent(data);
+    });
+    server.registerTool('move_help_center_topic', {
+        description: 'Put a topic inside another topic, or at the top level, at a given place in the list. Affects only the named language. Moving a topic into itself or one of its own subtopics is rejected.',
+        inputSchema: {
+            help_center_id: z.string().describe('The help center ID'),
+            category_entity_id: z.string().describe('The topic entity ID'),
+            parent_category_entity_id: z
+                .string()
+                .nullable()
+                .describe('The topic to put it inside; null for the top level.'),
+            language_code: z.string().describe("Which language's tree to change."),
+            position: z.number().int().min(0).describe('Where among its siblings it goes; 0 is first.'),
+        },
+    }, async ({ help_center_id, ...body }) => {
+        const data = (await client.POST('/hc/{helpCenterId}/structure/move-topic', {
+            params: { path: { helpCenterId: help_center_id } },
+            body,
+        })).data;
+        return jsonContent(data);
+    });
+    server.registerTool('reorder_help_center_tree', {
+        description: 'Set the order of everything directly inside one topic — subtopics and articles together. ordered_ids is the complete new order; read get_help_center_tree first, because an id you leave out is not moved but the ones you list are placed around it.',
+        inputSchema: {
+            help_center_id: z.string().describe('The help center ID'),
+            parent_category_entity_id: z
+                .string()
+                .nullable()
+                .describe('Whose children to reorder; null for the top level.'),
+            language_code: z.string().describe("Which language's tree to change."),
+            ordered_ids: z
+                .array(z.string())
+                .min(1)
+                .describe('Entity ids of the children, in the order they should appear.'),
+        },
+    }, async ({ help_center_id, ...body }) => {
+        const data = (await client.POST('/hc/{helpCenterId}/structure/reorder', {
+            params: { path: { helpCenterId: help_center_id } },
+            body,
+        })).data;
+        return jsonContent(data);
     });
 }
 //# sourceMappingURL=help-center.js.map