@tacitai/mcp-server 0.1.0 → 0.2.0

package/dist/tools/kb.js

@@ -0,0 +1,687 @@
+// SPDX-License-Identifier: MIT
+/**
+ * KB tools — CLI wrappers for knowledge collections, articles, categories,
+ * and browse/promote flows on the Axum REST API.
+ *
+ * Routes (Axum, all under /api/v1):
+ *   GET/POST         /knowledge/collections
+ *   PATCH/DELETE      /knowledge/collections/:id
+ *   GET/POST         /knowledge/articles
+ *   GET/PUT          /knowledge/articles/:id
+ *   GET              /knowledge/browse
+ *   POST             /knowledge/articles/from-artifact/:id
+ *   GET/POST         /knowledge/categories
+ */
+import { z } from 'zod';
+import { getClient, TacitApiError, TokenExpiredError } from '../client.js';
+import { apiErrorResult as sharedApiErrorResult } from './errors.js';
+function apiErrorResult(err, toolName) {
+    if (err instanceof TokenExpiredError) {
+        return {
+            content: [{ type: 'text', text: err.message }],
+            isError: true,
+        };
+    }
+    if (err instanceof TacitApiError) {
+        return { content: [{ type: 'text', text: `API error ${err.statusCode} on ${toolName}: ${err.body}` }], isError: true };
+    }
+    const msg = err instanceof Error ? err.message : String(err);
+    return { content: [{ type: 'text', text: `Error: ${msg}` }], isError: true };
+}
+// ─── tacit_kb_list_collections ──────────────────────────────────────────────
+export const listCollectionsInputSchema = z.object({
+    kb_category_id: z.string().optional().describe('Optional UUID of a KB category to filter collections by'),
+});
+export const LIST_COLLECTIONS_TOOL_DEF = {
+    name: 'tacit_kb_list_collections',
+    description: 'List all KB collections in the workspace, optionally filtered by category.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            kb_category_id: { type: 'string', description: 'Optional UUID of a KB category to filter by' },
+        },
+        required: [],
+    },
+};
+export function buildListCollectionsRequest(client, input) {
+    return {
+        async execute() {
+            try {
+                const result = await client.get('/api/v1/knowledge/collections', {
+                    kb_category_id: input.kb_category_id,
+                });
+                return { content: [{ type: 'text', text: JSON.stringify(result) }] };
+            }
+            catch (err) {
+                return apiErrorResult(err, 'tacit_kb_list_collections');
+            }
+        },
+    };
+}
+export async function handleListCollections(args) {
+    const parsed = listCollectionsInputSchema.safeParse(args);
+    if (!parsed.success) {
+        return { content: [{ type: 'text', text: `Invalid input: ${parsed.error.message}` }], isError: true };
+    }
+    return buildListCollectionsRequest(getClient(), parsed.data).execute();
+}
+// ─── tacit_kb_create_collection ─────────────────────────────────────────────
+export const createCollectionInputSchema = z.object({
+    slug: z.string().min(1).describe('URL-safe slug for the collection (unique per workspace)'),
+    name: z.string().min(1).describe('Collection display name'),
+    description: z.string().optional().describe('Optional description'),
+    kb_category_id: z.string().optional().describe('Optional UUID of the KB category to place this collection in'),
+});
+export const CREATE_COLLECTION_TOOL_DEF = {
+    name: 'tacit_kb_create_collection',
+    description: 'Create a new KB collection. Requires a unique slug within the workspace.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            slug: { type: 'string', description: 'URL-safe slug (unique per workspace)' },
+            name: { type: 'string', description: 'Collection display name' },
+            description: { type: 'string', description: 'Optional description' },
+            kb_category_id: { type: 'string', description: 'Optional KB category UUID' },
+        },
+        required: ['slug', 'name'],
+    },
+};
+export function buildCreateCollectionRequest(client, input) {
+    return {
+        async execute() {
+            try {
+                const body = { slug: input.slug, name: input.name };
+                if (input.description)
+                    body['description'] = input.description;
+                if (input.kb_category_id)
+                    body['kb_category_id'] = input.kb_category_id;
+                const result = await client.post('/api/v1/knowledge/collections', body);
+                return { content: [{ type: 'text', text: JSON.stringify(result) }] };
+            }
+            catch (err) {
+                return apiErrorResult(err, 'tacit_kb_create_collection');
+            }
+        },
+    };
+}
+export async function handleCreateCollection(args) {
+    const parsed = createCollectionInputSchema.safeParse(args);
+    if (!parsed.success) {
+        return { content: [{ type: 'text', text: `Invalid input: ${parsed.error.message}` }], isError: true };
+    }
+    return buildCreateCollectionRequest(getClient(), parsed.data).execute();
+}
+// ─── tacit_kb_update_collection ─────────────────────────────────────────────
+export const updateCollectionInputSchema = z.object({
+    id: z.string().min(1).describe('UUID of the collection to update'),
+    name: z.string().min(1).describe('Collection name (required by the backend on every update)'),
+    slug: z.string().optional().describe('Optional new slug (re-derived from name if omitted)'),
+    kb_category_id: z.string().nullable().optional().describe('KB category UUID to set; null clears it; omit to leave unchanged'),
+});
+export const UPDATE_COLLECTION_TOOL_DEF = {
+    name: 'tacit_kb_update_collection',
+    description: 'Update a KB collection\'s name, slug, or category. The backend requires `name` on every update. ' +
+        'Omit kb_category_id to leave it unchanged, or pass null to clear it.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            id: { type: 'string', description: 'UUID of the collection' },
+            name: { type: 'string', description: 'Collection name (required)' },
+            slug: { type: 'string', description: 'Optional new slug' },
+            kb_category_id: { type: ['string', 'null'], description: 'KB category UUID, or null to clear' },
+        },
+        required: ['id', 'name'],
+    },
+};
+export function buildUpdateCollectionRequest(client, input) {
+    return {
+        async execute() {
+            try {
+                const body = { name: input.name };
+                if (input.slug)
+                    body['slug'] = input.slug;
+                if (input.kb_category_id !== undefined)
+                    body['kb_category_id'] = input.kb_category_id;
+                const result = await client.patch(`/api/v1/knowledge/collections/${input.id}`, body);
+                return { content: [{ type: 'text', text: JSON.stringify(result) }] };
+            }
+            catch (err) {
+                return apiErrorResult(err, 'tacit_kb_update_collection');
+            }
+        },
+    };
+}
+export async function handleUpdateCollection(args) {
+    const parsed = updateCollectionInputSchema.safeParse(args);
+    if (!parsed.success) {
+        return { content: [{ type: 'text', text: `Invalid input: ${parsed.error.message}` }], isError: true };
+    }
+    return buildUpdateCollectionRequest(getClient(), parsed.data).execute();
+}
+// ─── tacit_kb_delete_collection ──────────────────────────────────────────────
+export const deleteCollectionInputSchema = z.object({
+    id: z.string().min(1).describe('UUID of the collection to delete'),
+});
+export const DELETE_COLLECTION_TOOL_DEF = {
+    name: 'tacit_kb_delete_collection',
+    description: 'Delete a KB collection. Blocked if any article would be orphaned (no other collection membership) — ' +
+        'move or demote such articles first.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            id: { type: 'string', description: 'UUID of the collection to delete' },
+        },
+        required: ['id'],
+    },
+};
+export function buildDeleteCollectionRequest(client, input) {
+    return {
+        async execute() {
+            try {
+                await client.delete(`/api/v1/knowledge/collections/${input.id}`);
+                return { content: [{ type: 'text', text: JSON.stringify({ deleted: true, collection_id: input.id }) }] };
+            }
+            catch (err) {
+                return apiErrorResult(err, 'tacit_kb_delete_collection');
+            }
+        },
+    };
+}
+export async function handleDeleteCollection(args) {
+    const parsed = deleteCollectionInputSchema.safeParse(args);
+    if (!parsed.success) {
+        return { content: [{ type: 'text', text: `Invalid input: ${parsed.error.message}` }], isError: true };
+    }
+    return buildDeleteCollectionRequest(getClient(), parsed.data).execute();
+}
+// ─── tacit_kb_list_articles ──────────────────────────────────────────────────
+export const listArticlesInputSchema = z.object({
+    collection_id: z.string().optional().describe('Optional UUID of a collection to filter articles by'),
+});
+export const LIST_ARTICLES_TOOL_DEF = {
+    name: 'tacit_kb_list_articles',
+    description: 'List KB articles in the workspace (up to 200, most recently updated first), optionally filtered by collection.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            collection_id: { type: 'string', description: 'Optional collection UUID to filter by' },
+        },
+        required: [],
+    },
+};
+export function buildListArticlesRequest(client, input) {
+    return {
+        async execute() {
+            try {
+                const result = await client.get('/api/v1/knowledge/articles', {
+                    collection_id: input.collection_id,
+                });
+                return { content: [{ type: 'text', text: JSON.stringify(result) }] };
+            }
+            catch (err) {
+                return apiErrorResult(err, 'tacit_kb_list_articles');
+            }
+        },
+    };
+}
+export async function handleListArticles(args) {
+    const parsed = listArticlesInputSchema.safeParse(args);
+    if (!parsed.success) {
+        return { content: [{ type: 'text', text: `Invalid input: ${parsed.error.message}` }], isError: true };
+    }
+    return buildListArticlesRequest(getClient(), parsed.data).execute();
+}
+// ─── tacit_kb_get_article ────────────────────────────────────────────────────
+export const getArticleInputSchema = z.object({
+    id: z.string().min(1).describe('UUID of the article'),
+});
+export const GET_ARTICLE_TOOL_DEF = {
+    name: 'tacit_kb_get_article',
+    description: 'Get a single KB article by ID, including its full content body and etag for optimistic-concurrency updates.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            id: { type: 'string', description: 'UUID of the article' },
+        },
+        required: ['id'],
+    },
+};
+export function buildGetArticleRequest(client, input) {
+    return {
+        async execute() {
+            try {
+                const result = await client.get(`/api/v1/knowledge/articles/${input.id}`);
+                const collectionId = typeof result['collection_id'] === 'string' ? result['collection_id'] : undefined;
+                const url = client.webUrl('kb_article', input.id, { collectionId });
+                const enriched = url ? { ...result, web_url: url } : result;
+                return { content: [{ type: 'text', text: JSON.stringify(enriched) }] };
+            }
+            catch (err) {
+                return apiErrorResult(err, 'tacit_kb_get_article');
+            }
+        },
+    };
+}
+export async function handleGetArticle(args) {
+    const parsed = getArticleInputSchema.safeParse(args);
+    if (!parsed.success) {
+        return { content: [{ type: 'text', text: `Invalid input: ${parsed.error.message}` }], isError: true };
+    }
+    return buildGetArticleRequest(getClient(), parsed.data).execute();
+}
+// ─── tacit_kb_create_article ─────────────────────────────────────────────────
+export const createArticleInputSchema = z.object({
+    collection_id: z.string().min(1).describe('UUID of the collection this article belongs to'),
+    slug: z.string().min(1).describe('URL-safe slug for the article (unique per collection)'),
+    title: z.string().min(1).describe('Article title'),
+    content: z.string().optional().describe('Article content body (markdown; defaults to empty)'),
+    status: z.enum(['DRAFT', 'PUBLISHED']).optional().describe('Status (defaults to DRAFT)'),
+    domain_id: z.string().optional().describe('Optional domain schema ID (user picker overrides collection default)'),
+});
+export const CREATE_ARTICLE_TOOL_DEF = {
+    name: 'tacit_kb_create_article',
+    description: 'Create a new KB article within a collection. Status defaults to DRAFT.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            collection_id: { type: 'string', description: 'UUID of the parent collection' },
+            slug: { type: 'string', description: 'URL-safe slug (unique per collection)' },
+            title: { type: 'string', description: 'Article title' },
+            content: { type: 'string', description: 'Article content body (markdown)' },
+            status: { type: 'string', enum: ['DRAFT', 'PUBLISHED'], description: 'Status (defaults to DRAFT)' },
+            domain_id: { type: 'string', description: 'Optional domain schema ID' },
+        },
+        required: ['collection_id', 'slug', 'title'],
+    },
+};
+export function buildCreateArticleRequest(client, input) {
+    return {
+        async execute() {
+            try {
+                const body = {
+                    collection_id: input.collection_id,
+                    slug: input.slug,
+                    title: input.title,
+                };
+                if (input.content !== undefined)
+                    body['content'] = input.content;
+                if (input.status)
+                    body['status'] = input.status;
+                if (input.domain_id)
+                    body['domain_id'] = input.domain_id;
+                const result = await client.post('/api/v1/knowledge/articles', body);
+                return { content: [{ type: 'text', text: JSON.stringify(result) }] };
+            }
+            catch (err) {
+                return apiErrorResult(err, 'tacit_kb_create_article');
+            }
+        },
+    };
+}
+export async function handleCreateArticle(args) {
+    const parsed = createArticleInputSchema.safeParse(args);
+    if (!parsed.success) {
+        return { content: [{ type: 'text', text: `Invalid input: ${parsed.error.message}` }], isError: true };
+    }
+    return buildCreateArticleRequest(getClient(), parsed.data).execute();
+}
+// ─── tacit_kb_update_article ─────────────────────────────────────────────────
+export const updateArticleInputSchema = z.object({
+    id: z.string().min(1).describe('UUID of the article to update'),
+    title: z.string().optional().describe('Updated title (keeps current if omitted)'),
+    content: z.string().optional().describe('Updated content body (keeps current if omitted)'),
+    status: z.enum(['DRAFT', 'PUBLISHED']).optional().describe('Updated status (keeps current if omitted)'),
+});
+export const UPDATE_ARTICLE_TOOL_DEF = {
+    name: 'tacit_kb_update_article',
+    description: 'Update an existing KB article. Only supply the fields you want to change — omitted fields keep their current values.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            id: { type: 'string', description: 'UUID of the article' },
+            title: { type: 'string', description: 'Updated title' },
+            content: { type: 'string', description: 'Updated content body' },
+            status: { type: 'string', enum: ['DRAFT', 'PUBLISHED'], description: 'Updated status' },
+        },
+        required: ['id'],
+    },
+};
+export function buildUpdateArticleRequest(client, input) {
+    return {
+        async execute() {
+            try {
+                const body = {};
+                if (input.title !== undefined)
+                    body['title'] = input.title;
+                if (input.content !== undefined)
+                    body['content'] = input.content;
+                if (input.status !== undefined)
+                    body['status'] = input.status;
+                const result = await client.put(`/api/v1/knowledge/articles/${input.id}`, body);
+                return { content: [{ type: 'text', text: JSON.stringify(result) }] };
+            }
+            catch (err) {
+                return apiErrorResult(err, 'tacit_kb_update_article');
+            }
+        },
+    };
+}
+export async function handleUpdateArticle(args) {
+    const parsed = updateArticleInputSchema.safeParse(args);
+    if (!parsed.success) {
+        return { content: [{ type: 'text', text: `Invalid input: ${parsed.error.message}` }], isError: true };
+    }
+    return buildUpdateArticleRequest(getClient(), parsed.data).execute();
+}
+// ─── tacit_kb_browse_tree ────────────────────────────────────────────────────
+export const browseTreeInputSchema = z.object({
+    kb_category_id: z.string().optional().describe('Optional UUID of a KB category to narrow the browse tree'),
+});
+export const BROWSE_TREE_TOOL_DEF = {
+    name: 'tacit_kb_browse_tree',
+    description: 'Browse the KB as a collection/article tree, optionally narrowed to one category.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            kb_category_id: { type: 'string', description: 'Optional KB category UUID to narrow by' },
+        },
+        required: [],
+    },
+};
+export function buildBrowseTreeRequest(client, input) {
+    return {
+        async execute() {
+            try {
+                const result = await client.get('/api/v1/knowledge/browse', {
+                    kb_category_id: input.kb_category_id,
+                });
+                return { content: [{ type: 'text', text: JSON.stringify(result) }] };
+            }
+            catch (err) {
+                return apiErrorResult(err, 'tacit_kb_browse_tree');
+            }
+        },
+    };
+}
+export async function handleBrowseTree(args) {
+    const parsed = browseTreeInputSchema.safeParse(args);
+    if (!parsed.success) {
+        return { content: [{ type: 'text', text: `Invalid input: ${parsed.error.message}` }], isError: true };
+    }
+    return buildBrowseTreeRequest(getClient(), parsed.data).execute();
+}
+// ─── tacit_kb_promote_from_artifact ─────────────────────────────────────────
+export const promoteFromArtifactInputSchema = z.object({
+    artifact_id: z.string().min(1).describe('UUID of the artifact to promote into the KB'),
+    collection_id: z.string().min(1).describe('UUID of an existing collection to place the promoted article in'),
+});
+export const PROMOTE_FROM_ARTIFACT_TOOL_DEF = {
+    name: 'tacit_kb_promote_from_artifact',
+    description: 'Promote an existing artifact into a published KB article, placing it in the given collection. ' +
+        'Idempotent — re-promoting an already-promoted artifact only applies the new placement.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            artifact_id: { type: 'string', description: 'UUID of the artifact to promote' },
+            collection_id: { type: 'string', description: 'UUID of an existing collection' },
+        },
+        required: ['artifact_id', 'collection_id'],
+    },
+};
+export function buildPromoteFromArtifactRequest(client, input) {
+    return {
+        async execute() {
+            try {
+                const body = {
+                    placement: {
+                        kb: { collections: [input.collection_id] },
+                    },
+                };
+                const result = await client.post(`/api/v1/knowledge/articles/from-artifact/${input.artifact_id}`, body);
+                return { content: [{ type: 'text', text: JSON.stringify(result) }] };
+            }
+            catch (err) {
+                return apiErrorResult(err, 'tacit_kb_promote_from_artifact');
+            }
+        },
+    };
+}
+export async function handlePromoteFromArtifact(args) {
+    const parsed = promoteFromArtifactInputSchema.safeParse(args);
+    if (!parsed.success) {
+        return { content: [{ type: 'text', text: `Invalid input: ${parsed.error.message}` }], isError: true };
+    }
+    return buildPromoteFromArtifactRequest(getClient(), parsed.data).execute();
+}
+// ─── tacit_kb_promote_from_catalog ─────────────────────────────────────────
+export const promoteFromCatalogInputSchema = z.object({
+    catalog_item_id: z.string().min(1).describe('UUID of the org_lake_catalog item to promote into the KB'),
+    collection_id: z.string().min(1).describe('UUID of an existing collection to place the promoted article in'),
+});
+export const PROMOTE_FROM_CATALOG_TOOL_DEF = {
+    name: 'tacit_kb_promote_from_catalog',
+    description: 'Promote a data lake catalog item into a published KB article. ' +
+        'Resolves the catalog item\'s artifact_id and delegates to the promote-from-artifact endpoint. ' +
+        'The catalog item must have an artifact_id (created via LAKE-17 artifact bridge).',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            catalog_item_id: { type: 'string', description: 'UUID of the catalog item' },
+            collection_id: { type: 'string', description: 'UUID of an existing collection' },
+        },
+        required: ['catalog_item_id', 'collection_id'],
+    },
+};
+export function buildPromoteFromCatalogRequest(client, input) {
+    return {
+        async execute() {
+            try {
+                const detail = await client.get(`/api/v1/org/lake/catalog/${input.catalog_item_id}`);
+                const artifactId = detail?.artifact_id;
+                if (!artifactId) {
+                    return {
+                        content: [{ type: 'text', text: `Catalog item ${input.catalog_item_id} has no artifact_id — run a sync first (LAKE-17 artifact bridge creates artifacts on ingest).` }],
+                        isError: true,
+                    };
+                }
+                const body = {
+                    placement: {
+                        kb: { collections: [input.collection_id] },
+                    },
+                };
+                const result = await client.post(`/api/v1/knowledge/articles/from-artifact/${artifactId}`, body);
+                return { content: [{ type: 'text', text: JSON.stringify(result) }] };
+            }
+            catch (err) {
+                return apiErrorResult(err, 'tacit_kb_promote_from_catalog');
+            }
+        },
+    };
+}
+export async function handlePromoteFromCatalog(args) {
+    const parsed = promoteFromCatalogInputSchema.safeParse(args);
+    if (!parsed.success) {
+        return { content: [{ type: 'text', text: `Invalid input: ${parsed.error.message}` }], isError: true };
+    }
+    return buildPromoteFromCatalogRequest(getClient(), parsed.data).execute();
+}
+// ─── tacit_kb_list_categories ────────────────────────────────────────────────
+export const listCategoriesInputSchema = z.object({
+    kind: z.string().optional().describe('Optional category kind filter (e.g. "domain")'),
+    include_archived: z.boolean().optional().describe('Include archived categories (default false)'),
+});
+export const LIST_CATEGORIES_TOOL_DEF = {
+    name: 'tacit_kb_list_categories',
+    description: 'List KB categories in the workspace, optionally filtered by kind and including archived ones.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            kind: { type: 'string', description: 'Optional category kind filter' },
+            include_archived: { type: 'boolean', description: 'Include archived categories (default false)' },
+        },
+        required: [],
+    },
+};
+export function buildListCategoriesRequest(client, input) {
+    return {
+        async execute() {
+            try {
+                const result = await client.get('/api/v1/knowledge/categories', {
+                    kind: input.kind,
+                    include_archived: input.include_archived,
+                });
+                return { content: [{ type: 'text', text: JSON.stringify(result) }] };
+            }
+            catch (err) {
+                return apiErrorResult(err, 'tacit_kb_list_categories');
+            }
+        },
+    };
+}
+export async function handleListCategories(args) {
+    const parsed = listCategoriesInputSchema.safeParse(args);
+    if (!parsed.success) {
+        return { content: [{ type: 'text', text: `Invalid input: ${parsed.error.message}` }], isError: true };
+    }
+    return buildListCategoriesRequest(getClient(), parsed.data).execute();
+}
+// ─── tacit_kb_create_category ────────────────────────────────────────────────
+export const createCategoryInputSchema = z.object({
+    name: z.string().min(1).describe('Category name (unique per workspace)'),
+    description: z.string().optional().describe('Optional description'),
+});
+export const CREATE_CATEGORY_TOOL_DEF = {
+    name: 'tacit_kb_create_category',
+    description: 'Create a new KB category (kind="domain"). Requires domain categories to be enabled for the workspace.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            name: { type: 'string', description: 'Category name (unique per workspace)' },
+            description: { type: 'string', description: 'Optional description' },
+        },
+        required: ['name'],
+    },
+};
+export function buildCreateCategoryRequest(client, input) {
+    return {
+        async execute() {
+            try {
+                const body = { name: input.name };
+                if (input.description)
+                    body['description'] = input.description;
+                const result = await client.post('/api/v1/knowledge/categories', body);
+                return { content: [{ type: 'text', text: JSON.stringify(result) }] };
+            }
+            catch (err) {
+                return apiErrorResult(err, 'tacit_kb_create_category');
+            }
+        },
+    };
+}
+export async function handleCreateCategory(args) {
+    const parsed = createCategoryInputSchema.safeParse(args);
+    if (!parsed.success) {
+        return { content: [{ type: 'text', text: `Invalid input: ${parsed.error.message}` }], isError: true };
+    }
+    return buildCreateCategoryRequest(getClient(), parsed.data).execute();
+}
+export function registerKbTools(server, getClientFn) {
+    server.tool('tacit_kb_list_collections', LIST_COLLECTIONS_TOOL_DEF.description, listCollectionsInputSchema.shape, async (args) => {
+        const client = await getClientFn();
+        return buildListCollectionsRequest(client, args).execute();
+    });
+    server.tool('tacit_kb_create_collection', CREATE_COLLECTION_TOOL_DEF.description, createCollectionInputSchema.shape, async (args) => {
+        const client = await getClientFn();
+        return buildCreateCollectionRequest(client, args).execute();
+    });
+    server.tool('tacit_kb_update_collection', UPDATE_COLLECTION_TOOL_DEF.description, updateCollectionInputSchema.shape, async (args) => {
+        const client = await getClientFn();
+        return buildUpdateCollectionRequest(client, args).execute();
+    });
+    server.tool('tacit_kb_delete_collection', DELETE_COLLECTION_TOOL_DEF.description, deleteCollectionInputSchema.shape, async (args) => {
+        const client = await getClientFn();
+        return buildDeleteCollectionRequest(client, args).execute();
+    });
+    server.tool('tacit_kb_list_articles', LIST_ARTICLES_TOOL_DEF.description, listArticlesInputSchema.shape, async (args) => {
+        const client = await getClientFn();
+        return buildListArticlesRequest(client, args).execute();
+    });
+    server.tool('tacit_kb_get_article', GET_ARTICLE_TOOL_DEF.description, getArticleInputSchema.shape, async (args) => {
+        const client = await getClientFn();
+        return buildGetArticleRequest(client, args).execute();
+    });
+    server.tool('tacit_kb_create_article', CREATE_ARTICLE_TOOL_DEF.description, createArticleInputSchema.shape, async (args) => {
+        const client = await getClientFn();
+        return buildCreateArticleRequest(client, args).execute();
+    });
+    server.tool('tacit_kb_update_article', UPDATE_ARTICLE_TOOL_DEF.description, updateArticleInputSchema.shape, async (args) => {
+        const client = await getClientFn();
+        return buildUpdateArticleRequest(client, args).execute();
+    });
+    server.tool('tacit_kb_browse_tree', BROWSE_TREE_TOOL_DEF.description, browseTreeInputSchema.shape, async (args) => {
+        const client = await getClientFn();
+        return buildBrowseTreeRequest(client, args).execute();
+    });
+    server.tool('tacit_kb_promote_from_artifact', PROMOTE_FROM_ARTIFACT_TOOL_DEF.description, promoteFromArtifactInputSchema.shape, async (args) => {
+        const client = await getClientFn();
+        return buildPromoteFromArtifactRequest(client, args).execute();
+    });
+    server.tool('tacit_kb_promote_from_catalog', PROMOTE_FROM_CATALOG_TOOL_DEF.description, promoteFromCatalogInputSchema.shape, async (args) => {
+        const client = await getClientFn();
+        return buildPromoteFromCatalogRequest(client, args).execute();
+    });
+    server.tool('tacit_kb_list_categories', LIST_CATEGORIES_TOOL_DEF.description, listCategoriesInputSchema.shape, async (args) => {
+        const client = await getClientFn();
+        return buildListCategoriesRequest(client, args).execute();
+    });
+    server.tool('tacit_kb_create_category', CREATE_CATEGORY_TOOL_DEF.description, createCategoryInputSchema.shape, async (args) => {
+        const client = await getClientFn();
+        return buildCreateCategoryRequest(client, args).execute();
+    });
+    server.tool('tacit_kb_freshness', 'Get a freshness report for knowledge base articles.', {}, async () => {
+        try {
+            const client = await getClientFn();
+            const data = await client.get('/api/v1/knowledge/freshness');
+            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+        }
+        catch (err) {
+            return sharedApiErrorResult(err, '/api/v1/knowledge/freshness');
+        }
+    });
+    server.tool('tacit_kb_pull_source', 'Trigger a sync/pull from a registered data lake source to ingest content into the knowledge base.', {
+        source_id: z.string().uuid().describe('Source UUID'),
+        confirm_deletions: z.boolean().optional().describe('Delete items removed from source (default: false)'),
+    }, async (args) => {
+        try {
+            const client = await getClientFn();
+            const data = await client.post('/api/v1/org/lake/sync', {
+                source_id: args.source_id,
+                confirm_deletions: args.confirm_deletions ?? false,
+            });
+            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+        }
+        catch (err) {
+            return sharedApiErrorResult(err, '/api/v1/org/lake/sync');
+        }
+    });
+    server.tool('tacit_kb_register_source', 'Register a data source for lake-to-KB ingestion.', {
+        uri: z.string().describe('Source URI (e.g. github://owner/repo, file:///path, s3://bucket/prefix)'),
+        kind: z.enum(['git', 'local_fs', 's3']).describe('Source connector type'),
+        sync_mode: z.enum(['full', 'incremental']).optional().describe('Sync mode (default: full)'),
+        sync_interval_secs: z.number().optional().describe('Auto-sync interval in seconds'),
+    }, async (args) => {
+        try {
+            const client = await getClientFn();
+            const data = await client.post('/api/v1/org/lake/onboard', {
+                uri: args.uri,
+                kind: args.kind,
+                sync_mode: args.sync_mode ?? 'full',
+                sync_interval_secs: args.sync_interval_secs,
+            });
+            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+        }
+        catch (err) {
+            return sharedApiErrorResult(err, '/api/v1/org/lake/onboard');
+        }
+    });
+}