kibi-mcp 0.17.4 → 0.19.0

package/dist/server/json-schema-to-zod.js

@@ -0,0 +1,104 @@
+import { z } from "zod";
+// implements REQ-002
+export function jsonSchemaToZod(schema) {
+    if (!schema || typeof schema !== "object") {
+        return z.any();
+    }
+    const obj = schema;
+    if (Array.isArray(obj.enum) && obj.enum.length > 0) {
+        const description = typeof obj.description === "string" ? obj.description : undefined;
+        const literals = obj.enum.filter((value) => typeof value === "string" ||
+            typeof value === "number" ||
+            typeof value === "boolean" ||
+            value === null);
+        if (literals.length === 0) {
+            return description ? z.any().describe(description) : z.any();
+        }
+        const literalSchemas = literals.map((value) => z.literal(value));
+        if (literalSchemas.length === 1) {
+            const single = literalSchemas[0];
+            if (!single) {
+                return description ? z.any().describe(description) : z.any();
+            }
+            return description ? single.describe(description) : single;
+        }
+        const union = z.union(literalSchemas);
+        return description ? union.describe(description) : union;
+    }
+    const schemaType = typeof obj.type === "string" ? obj.type : undefined;
+    switch (schemaType) {
+        case "object": {
+            const properties = obj.properties && typeof obj.properties === "object"
+                ? obj.properties
+                : {};
+            const required = new Set(Array.isArray(obj.required)
+                ? obj.required.filter((k) => typeof k === "string" && k.length > 0)
+                : []);
+            const shape = {};
+            for (const [key, value] of Object.entries(properties)) {
+                const propSchema = jsonSchemaToZod(value);
+                shape[key] = required.has(key) ? propSchema : propSchema.optional();
+            }
+            const objectSchema = obj.additionalProperties === false
+                ? z.object(shape)
+                : z.looseObject(shape);
+            const description = typeof obj.description === "string" ? obj.description : undefined;
+            return description ? objectSchema.describe(description) : objectSchema;
+        }
+        case "array": {
+            const itemSchema = jsonSchemaToZod(obj.items);
+            let arraySchema = z.array(itemSchema);
+            const description = typeof obj.description === "string" ? obj.description : undefined;
+            if (typeof obj.minItems === "number") {
+                arraySchema = arraySchema.min(obj.minItems);
+            }
+            if (typeof obj.maxItems === "number") {
+                arraySchema = arraySchema.max(obj.maxItems);
+            }
+            return description ? arraySchema.describe(description) : arraySchema;
+        }
+        case "string": {
+            let s = z.string();
+            const description = typeof obj.description === "string" ? obj.description : undefined;
+            if (typeof obj.minLength === "number") {
+                s = s.min(obj.minLength);
+            }
+            if (typeof obj.maxLength === "number") {
+                s = s.max(obj.maxLength);
+            }
+            return description ? s.describe(description) : s;
+        }
+        case "number": {
+            let n = z.number();
+            const description = typeof obj.description === "string" ? obj.description : undefined;
+            if (typeof obj.minimum === "number") {
+                n = n.min(obj.minimum);
+            }
+            if (typeof obj.maximum === "number") {
+                n = n.max(obj.maximum);
+            }
+            return description ? n.describe(description) : n;
+        }
+        case "integer": {
+            let n = z.number().int();
+            const description = typeof obj.description === "string" ? obj.description : undefined;
+            if (typeof obj.minimum === "number") {
+                n = n.min(obj.minimum);
+            }
+            if (typeof obj.maximum === "number") {
+                n = n.max(obj.maximum);
+            }
+            return description ? n.describe(description) : n;
+        }
+        case "boolean": {
+            const b = z.boolean();
+            const description = typeof obj.description === "string" ? obj.description : undefined;
+            return description ? b.describe(description) : b;
+        }
+        default: {
+            const anySchema = z.any();
+            const description = typeof obj.description === "string" ? obj.description : undefined;
+            return description ? anySchema.describe(description) : anySchema;
+        }
+    }
+}

package/dist/server/tool-registration.js

@@ -0,0 +1,131 @@
+// implements REQ-002, REQ-013
+export function registerConfiguredTools(server, runtime, registerTool) {
+    const toolDef = (name) => {
+        const t = runtime.tools.find((tool) => tool.name === name);
+        if (!t)
+            throw new Error(`Unknown tool: ${name}`);
+        return t;
+    };
+    const register = ({ name, handler }) => {
+        const definition = toolDef(name);
+        registerTool(server, name, definition.description, definition.inputSchema, handler, runtime);
+    };
+    // INTENTIONAL ARGUMENT CASTS: The `args as (unknown as)? XyzArgs` casts below
+    // bridge the generic ToolHandler (which receives Record<string, unknown>) to the
+    // specific handler argument types. Argument shapes are validated by Zod schemas
+    // (via jsonSchemaToZod) before the handler is invoked, so the casts are safe at runtime.
+    register({
+        name: "kb_query",
+        handler: async (args) => {
+            const prolog = await runtime.ensureProlog();
+            return runtime.handleKbQuery(prolog, args);
+        },
+    });
+    register({
+        name: "kb_search",
+        handler: async (args) => {
+            const prolog = await runtime.ensureProlog();
+            return runtime.handleKbSearch(prolog, args);
+        },
+    });
+    register({
+        name: "kb_status",
+        handler: async (args) => {
+            const prolog = await runtime.ensureProlog();
+            return runtime.handleKbStatus(prolog, args);
+        },
+    });
+    register({
+        name: "kb_skills_list",
+        handler: async (args) => runtime.handleKbSkillsList(args),
+    });
+    register({
+        name: "kb_skills_load",
+        handler: async (args) => runtime.handleKbSkillsLoad(args),
+    });
+    register({
+        name: "kb_skills_read",
+        handler: async (args) => runtime.handleKbSkillsRead(args),
+    });
+    register({
+        name: "kb_find_gaps",
+        handler: async (args) => {
+            const prolog = await runtime.ensureProlog();
+            return runtime.handleKbFindGaps(prolog, args);
+        },
+    });
+    register({
+        name: "kb_coverage",
+        handler: async (args) => {
+            const prolog = await runtime.ensureProlog();
+            return runtime.handleKbCoverage(prolog, args);
+        },
+    });
+    register({
+        name: "kb_graph",
+        handler: async (args) => {
+            const prolog = await runtime.ensureProlog();
+            return runtime.handleKbGraph(prolog, args);
+        },
+    });
+    register({
+        name: "kb_sparql_remote",
+        handler: async (args) => {
+            const prolog = await runtime.ensureProlog();
+            return runtime.handleSparql(prolog, args);
+        },
+    });
+    register({
+        name: "kb_semantic_advisor",
+        handler: async (args) => runtime.handleKbSemanticAdvisor(args),
+    });
+    register({
+        name: "kb_upsert",
+        handler: async (args) => {
+            const prolog = await runtime.ensureProlog();
+            return runtime.handleKbUpsert(prolog, args);
+        },
+    });
+    register({
+        name: "kb_validate_upsert",
+        handler: async (args) => {
+            const prolog = await runtime.ensureProlog();
+            return runtime.handleKbValidateUpsert(prolog, args);
+        },
+    });
+    register({
+        name: "kb_delete",
+        handler: async (args) => {
+            const prolog = await runtime.ensureProlog();
+            return runtime.handleKbDelete(prolog, args);
+        },
+    });
+    register({
+        name: "kb_check",
+        handler: async (args) => {
+            const prolog = await runtime.ensureProlog();
+            return runtime.handleKbCheck(prolog, args);
+        },
+    });
+    register({
+        name: "kb_model_requirement",
+        handler: async (args) => {
+            const prolog = await runtime.ensureProlog();
+            return runtime.handleKbModelRequirement(prolog, args);
+        },
+    });
+    register({
+        name: "kb_suggest_predicates",
+        handler: async (args) => {
+            const prolog = await runtime.ensureProlog();
+            return runtime.handleKbSuggestPredicates(prolog, args);
+        },
+    });
+    register({
+        name: "kb_autopilot_generate",
+        handler: async (args) => {
+            const prolog = await runtime.ensureProlog();
+            return runtime.handleKbAutopilotGenerate(prolog, args);
+        },
+    });
+}

package/dist/server/tool-types.js

@@ -0,0 +1 @@
+export {};

package/dist/server/tools-runtime.js

@@ -0,0 +1,76 @@
+import { DIAGNOSTIC_MODE_ENABLED, appendUsageLogLine, classifyDiagnosticError, deriveDiagnosticFields, extractToolCallPayload, } from "../diagnostics.js";
+import { TOOLS } from "../tools-config.js";
+import { handleKbAutopilotGenerate } from "../tools/autopilot-generate.js";
+import { handleKbCheck } from "../tools/check.js";
+import { handleKbCoverage } from "../tools/coverage.js";
+import { handleKbDelete } from "../tools/delete.js";
+import { handleKbFindGaps } from "../tools/find-gaps.js";
+import { handleKbGraph } from "../tools/graph.js";
+import { handleKbModelRequirement } from "../tools/model-requirement.js";
+import { handleKbQuery } from "../tools/query.js";
+import { handleKbSearch } from "../tools/search.js";
+import { handleKbSemanticAdvisor } from "../tools/semantic-advisor.js";
+import { handleKbSkillsList, handleKbSkillsLoad, handleKbSkillsRead, } from "../tools/skills.js";
+import { handleSparql } from "../tools/sparql.js";
+import { handleKbStatus } from "../tools/status.js";
+import { handleKbSuggestPredicates } from "../tools/suggest-predicates.js";
+import { handleKbUpsert } from "../tools/upsert.js";
+import { handleKbValidateUpsert } from "../tools/validate-upsert.js";
+const defaultToolsServerDeps = {
+    getSessionModule: () => import("./session.js"),
+};
+let sessionModulePromise = null;
+// implements REQ-008
+export function _setToolsServerDepsForTests(deps, resetPromise = false) {
+    defaultToolsServerDeps.getSessionModule =
+        deps.getSessionModule ?? defaultToolsServerDeps.getSessionModule;
+    if (resetPromise) {
+        sessionModulePromise = null;
+    }
+}
+// implements REQ-012
+export function _resetSessionModulePromise() {
+    sessionModulePromise = null;
+}
+/* v8 ignore next (3 lines) — lazy async module loader; body only executes once per process
+ * when DEFAULT_TOOLS_RUNTIME.activeBranchName/ensureProlog/etc. are first called.
+ * Cannot be re-triggered without process restart (sessionModulePromise is module-level). */
+async function getSessionModule() {
+    sessionModulePromise ??= defaultToolsServerDeps.getSessionModule();
+    return sessionModulePromise;
+}
+export const DEFAULT_TOOLS_RUNTIME = {
+    diagnosticModeEnabled: () => DIAGNOSTIC_MODE_ENABLED,
+    appendUsageLogLine,
+    classifyDiagnosticError,
+    deriveDiagnosticFields,
+    extractToolCallPayload,
+    // INTENTIONAL: TOOLS is imported as a Zod-inferred schema type; ToolConfig is the
+    // runtime interface with looser Record<string, unknown> inputSchema. The cast is safe
+    // because the tool definitions are statically authored and validated at startup.
+    tools: TOOLS,
+    activeBranchName: async () => (await getSessionModule()).activeBranchName,
+    ensureProlog: async () => (await getSessionModule()).ensureProlog(),
+    resetProlog: async (reason) => (await getSessionModule()).resetProlog(reason),
+    inFlightRequests: async () => (await getSessionModule()).inFlightRequests,
+    isShuttingDown: async () => (await getSessionModule()).isShuttingDown,
+    prologProcess: async () => (await getSessionModule()).prologProcess,
+    handleKbCheck,
+    handleKbCoverage,
+    handleKbDelete,
+    handleKbFindGaps,
+    handleKbGraph,
+    handleSparql,
+    handleKbQuery,
+    handleKbSearch,
+    handleKbStatus,
+    handleKbSemanticAdvisor,
+    handleKbSkillsList,
+    handleKbSkillsLoad,
+    handleKbSkillsRead,
+    handleKbUpsert,
+    handleKbValidateUpsert,
+    handleKbModelRequirement,
+    handleKbSuggestPredicates,
+    handleKbAutopilotGenerate,
+};

package/dist/server/tools.js

@@ -16,86 +16,15 @@
  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 import process from "node:process";
-import { z } from "zod";
-import { DIAGNOSTIC_MODE_ENABLED, appendUsageLogLine, classifyDiagnosticError, deriveDiagnosticFields, extractToolCallPayload, } from "../diagnostics.js";
 import { isMcpDebugEnabled } from "../env.js";
-import { TOOLS } from "../tools-config.js";
-import { handleKbAutopilotGenerate, } from "../tools/autopilot-generate.js";
-import { handleKbCheck } from "../tools/check.js";
-import { handleKbCoverage } from "../tools/coverage.js";
-import { handleKbDelete } from "../tools/delete.js";
-import { handleKbFindGaps } from "../tools/find-gaps.js";
-import { handleKbGraph } from "../tools/graph.js";
-import { handleKbModelRequirement, } from "../tools/model-requirement.js";
-import { handleKbQuery } from "../tools/query.js";
-import { handleKbSearch } from "../tools/search.js";
-import { handleKbSemanticAdvisor, } from "../tools/semantic-advisor.js";
-import { handleKbSkillsList, handleKbSkillsLoad, handleKbSkillsRead, } from "../tools/skills.js";
-import { handleSparql } from "../tools/sparql.js";
-import { handleKbStatus } from "../tools/status.js";
-import { handleKbSuggestPredicates, } from "../tools/suggest-predicates.js";
-import { handleKbUpsert } from "../tools/upsert.js";
-import { handleKbValidateUpsert } from "../tools/validate-upsert.js";
+import { appendDiagnosticErrorUsage, appendDiagnosticSuccessUsage, } from "./diagnostic-usage.js";
+import { jsonSchemaToZod } from "./json-schema-to-zod.js";
+import { registerConfiguredTools } from "./tool-registration.js";
+import { DEFAULT_TOOLS_RUNTIME, _resetSessionModulePromise, _setToolsServerDepsForTests, } from "./tools-runtime.js";
+export { jsonSchemaToZod } from "./json-schema-to-zod.js";
+export { _resetSessionModulePromise, _setToolsServerDepsForTests };
 const DEFAULT_TOOL_TIMEOUT_MS = 90_000;
 const TOOL_TIMEOUT_ENV = "KIBI_MCP_TOOL_TIMEOUT_MS";
-const defaultToolsServerDeps = {
-    getSessionModule: () => import("./session.js"),
-};
-// implements REQ-008
-export function _setToolsServerDepsForTests(deps, resetPromise = false) {
-    defaultToolsServerDeps.getSessionModule =
-        deps.getSessionModule ?? defaultToolsServerDeps.getSessionModule;
-    if (resetPromise) {
-        sessionModulePromise = null;
-    }
-}
-// implements REQ-012
-export function _resetSessionModulePromise() {
-    sessionModulePromise = null;
-}
-let sessionModulePromise = null;
-/* v8 ignore next (3 lines) — lazy async module loader; body only executes once per process
- * when DEFAULT_TOOLS_RUNTIME.activeBranchName/ensureProlog/etc. are first called.
- * Cannot be re-triggered without process restart (sessionModulePromise is module-level). */
-async function getSessionModule() {
-    sessionModulePromise ??= defaultToolsServerDeps.getSessionModule();
-    return sessionModulePromise;
-}
-const DEFAULT_TOOLS_RUNTIME = {
-    diagnosticModeEnabled: () => DIAGNOSTIC_MODE_ENABLED,
-    appendUsageLogLine,
-    classifyDiagnosticError,
-    deriveDiagnosticFields,
-    extractToolCallPayload,
-    // INTENTIONAL: TOOLS is imported as a Zod-inferred schema type; ToolConfig is the
-    // runtime interface with looser Record<string, unknown> inputSchema. The cast is safe
-    // because the tool definitions are statically authored and validated at startup.
-    tools: TOOLS,
-    activeBranchName: async () => (await getSessionModule()).activeBranchName,
-    ensureProlog: async () => (await getSessionModule()).ensureProlog(),
-    resetProlog: async (reason) => (await getSessionModule()).resetProlog(reason),
-    inFlightRequests: async () => (await getSessionModule()).inFlightRequests,
-    isShuttingDown: async () => (await getSessionModule()).isShuttingDown,
-    prologProcess: async () => (await getSessionModule()).prologProcess,
-    handleKbCheck,
-    handleKbCoverage,
-    handleKbDelete,
-    handleKbFindGaps,
-    handleKbGraph,
-    handleSparql,
-    handleKbQuery,
-    handleKbSearch,
-    handleKbStatus,
-    handleKbSemanticAdvisor,
-    handleKbSkillsList,
-    handleKbSkillsLoad,
-    handleKbSkillsRead,
-    handleKbUpsert,
-    handleKbValidateUpsert,
-    handleKbModelRequirement,
-    handleKbSuggestPredicates,
-    handleKbAutopilotGenerate,
-};
 // implements REQ-008
 function debugLog(...args) {
     if (isMcpDebugEnabled()) {
@@ -140,109 +69,6 @@ async function withToolTimeout(toolName, operation, onTimeout) {
     }
 }
 // implements REQ-002
-export function jsonSchemaToZod(schema) {
-    if (!schema || typeof schema !== "object") {
-        return z.any();
-    }
-    const obj = schema;
-    if (Array.isArray(obj.enum) && obj.enum.length > 0) {
-        const description = typeof obj.description === "string" ? obj.description : undefined;
-        const literals = obj.enum.filter((value) => typeof value === "string" ||
-            typeof value === "number" ||
-            typeof value === "boolean" ||
-            value === null);
-        if (literals.length === 0) {
-            return description ? z.any().describe(description) : z.any();
-        }
-        const literalSchemas = literals.map((value) => z.literal(value));
-        if (literalSchemas.length === 1) {
-            const single = literalSchemas[0];
-            if (!single) {
-                return description ? z.any().describe(description) : z.any();
-            }
-            return description ? single.describe(description) : single;
-        }
-        const union = z.union(literalSchemas);
-        return description ? union.describe(description) : union;
-    }
-    const schemaType = typeof obj.type === "string" ? obj.type : undefined;
-    switch (schemaType) {
-        case "object": {
-            const properties = obj.properties && typeof obj.properties === "object"
-                ? obj.properties
-                : {};
-            const required = new Set(Array.isArray(obj.required)
-                ? obj.required.filter((k) => typeof k === "string" && k.length > 0)
-                : []);
-            const shape = {};
-            for (const [key, value] of Object.entries(properties)) {
-                const propSchema = jsonSchemaToZod(value);
-                shape[key] = required.has(key) ? propSchema : propSchema.optional();
-            }
-            const objectSchema = obj.additionalProperties === false
-                ? z.object(shape)
-                : z.looseObject(shape);
-            const description = typeof obj.description === "string" ? obj.description : undefined;
-            return description ? objectSchema.describe(description) : objectSchema;
-        }
-        case "array": {
-            const itemSchema = jsonSchemaToZod(obj.items);
-            let arraySchema = z.array(itemSchema);
-            const description = typeof obj.description === "string" ? obj.description : undefined;
-            if (typeof obj.minItems === "number") {
-                arraySchema = arraySchema.min(obj.minItems);
-            }
-            if (typeof obj.maxItems === "number") {
-                arraySchema = arraySchema.max(obj.maxItems);
-            }
-            return description ? arraySchema.describe(description) : arraySchema;
-        }
-        case "string": {
-            let s = z.string();
-            const description = typeof obj.description === "string" ? obj.description : undefined;
-            if (typeof obj.minLength === "number") {
-                s = s.min(obj.minLength);
-            }
-            if (typeof obj.maxLength === "number") {
-                s = s.max(obj.maxLength);
-            }
-            return description ? s.describe(description) : s;
-        }
-        case "number": {
-            let n = z.number();
-            const description = typeof obj.description === "string" ? obj.description : undefined;
-            if (typeof obj.minimum === "number") {
-                n = n.min(obj.minimum);
-            }
-            if (typeof obj.maximum === "number") {
-                n = n.max(obj.maximum);
-            }
-            return description ? n.describe(description) : n;
-        }
-        case "integer": {
-            let n = z.number().int();
-            const description = typeof obj.description === "string" ? obj.description : undefined;
-            if (typeof obj.minimum === "number") {
-                n = n.min(obj.minimum);
-            }
-            if (typeof obj.maximum === "number") {
-                n = n.max(obj.maximum);
-            }
-            return description ? n.describe(description) : n;
-        }
-        case "boolean": {
-            const b = z.boolean();
-            const description = typeof obj.description === "string" ? obj.description : undefined;
-            return description ? b.describe(description) : b;
-        }
-        default: {
-            const anySchema = z.any();
-            const description = typeof obj.description === "string" ? obj.description : undefined;
-            return description ? anySchema.describe(description) : anySchema;
-        }
-    }
-}
-// implements REQ-002
 export function addTool(server, name, description, inputSchema, handler, 
 // INTENTIONAL: DEFAULT_TOOLS_RUNTIME is typed as ToolsRuntime<PrologProcess>; the
 // generic TProlog parameter exists so tests can inject a mock type. The cast is safe
@@ -293,23 +119,15 @@ runtime = DEFAULT_TOOLS_RUNTIME) {
                 });
                 // Log usage in diagnostic mode
                 if (diagnosticModeEnabled) {
-                    const finishedAt = new Date();
-                    const diagnosticFields = runtime.deriveDiagnosticFields(name, businessArgs, telemetry, result);
-                    const processHandle = await runtime.prologProcess();
-                    const branchName = await runtime.activeBranchName();
-                    runtime.appendUsageLogLine({
-                        timestamp: finishedAt.toISOString(),
-                        request_id: requestId,
-                        tool: name,
+                    await appendDiagnosticSuccessUsage({
+                        runtime,
+                        toolName: name,
+                        requestId,
+                        args,
+                        businessArgs,
                         telemetry,
-                        business_args: businessArgs,
-                        status: "success",
-                        started_at: startedAt.toISOString(),
-                        finished_at: finishedAt.toISOString(),
-                        duration_ms: finishedAt.getTime() - startedAt.getTime(),
-                        prolog_pid: processHandle?.getPid() ?? null,
-                        active_branch: branchName,
-                        ...diagnosticFields,
+                        startedAt,
+                        result,
                     });
                 }
                 return result;
@@ -317,27 +135,16 @@ runtime = DEFAULT_TOOLS_RUNTIME) {
             catch (error) {
                 // Log error in diagnostic mode
                 if (diagnosticModeEnabled) {
-                    const finishedAt = new Date();
-                    const err = error instanceof Error ? error : new Error(String(error));
-                    const diagnosticErrorFields = runtime.classifyDiagnosticError(err);
-                    const processHandle = await runtime.prologProcess();
-                    const branchName = await runtime.activeBranchName();
-                    runtime.appendUsageLogLine({
-                        timestamp: finishedAt.toISOString(),
-                        request_id: requestId,
-                        tool: name,
+                    await appendDiagnosticErrorUsage({
+                        runtime,
+                        toolName: name,
+                        requestId,
+                        args,
+                        businessArgs,
                         telemetry,
-                        business_args: businessArgs,
-                        status: "error",
-                        started_at: startedAt.toISOString(),
-                        finished_at: finishedAt.toISOString(),
-                        duration_ms: finishedAt.getTime() - startedAt.getTime(),
-                        prolog_pid: processHandle?.getPid() ?? null,
-                        active_branch: branchName,
-                        reset_attempted: resetAttempted,
-                        reset_succeeded: resetSucceeded,
-                        reset_error: resetError,
-                        ...diagnosticErrorFields,
+                        startedAt,
+                        error,
+                        resetState: { resetAttempted, resetSucceeded, resetError },
                     });
                 }
                 throw error;
@@ -362,75 +169,5 @@ runtime = DEFAULT_TOOLS_RUNTIME) {
 export function registerAllTools(server, 
 // INTENTIONAL: same generic bridge cast as addTool — see comment there.
 runtime = DEFAULT_TOOLS_RUNTIME) {
-    const toolDef = (name) => {
-        const t = runtime.tools.find((tool) => tool.name === name);
-        if (!t)
-            throw new Error(`Unknown tool: ${name}`);
-        return t;
-    };
-    // INTENTIONAL ARGUMENT CASTS: The `args as (unknown as)? XyzArgs` casts below
-    // bridge the generic ToolHandler (which receives Record<string, unknown>) to the
-    // specific handler argument types. Argument shapes are validated by Zod schemas
-    // (via jsonSchemaToZod) before the handler is invoked, so the casts are safe at runtime.
-    addTool(server, "kb_query", toolDef("kb_query").description, toolDef("kb_query").inputSchema, async (args) => {
-        const prolog = await runtime.ensureProlog();
-        return runtime.handleKbQuery(prolog, args);
-    }, runtime);
-    addTool(server, "kb_search", toolDef("kb_search").description, toolDef("kb_search").inputSchema, async (args) => {
-        const prolog = await runtime.ensureProlog();
-        return runtime.handleKbSearch(prolog, args);
-    }, runtime);
-    addTool(server, "kb_status", toolDef("kb_status").description, toolDef("kb_status").inputSchema, async (args) => {
-        const prolog = await runtime.ensureProlog();
-        return runtime.handleKbStatus(prolog, args);
-    }, runtime);
-    addTool(server, "kb_skills_list", toolDef("kb_skills_list").description, toolDef("kb_skills_list").inputSchema, async (args) => runtime.handleKbSkillsList(args), runtime);
-    addTool(server, "kb_skills_load", toolDef("kb_skills_load").description, toolDef("kb_skills_load").inputSchema, async (args) => runtime.handleKbSkillsLoad(args), runtime);
-    addTool(server, "kb_skills_read", toolDef("kb_skills_read").description, toolDef("kb_skills_read").inputSchema, async (args) => runtime.handleKbSkillsRead(args), runtime);
-    addTool(server, "kb_find_gaps", toolDef("kb_find_gaps").description, toolDef("kb_find_gaps").inputSchema, async (args) => {
-        const prolog = await runtime.ensureProlog();
-        return runtime.handleKbFindGaps(prolog, args);
-    }, runtime);
-    addTool(server, "kb_coverage", toolDef("kb_coverage").description, toolDef("kb_coverage").inputSchema, async (args) => {
-        const prolog = await runtime.ensureProlog();
-        return runtime.handleKbCoverage(prolog, args);
-    }, runtime);
-    addTool(server, "kb_graph", toolDef("kb_graph").description, toolDef("kb_graph").inputSchema, async (args) => {
-        const prolog = await runtime.ensureProlog();
-        return runtime.handleKbGraph(prolog, args);
-    }, runtime);
-    addTool(server, "kb_sparql_remote", toolDef("kb_sparql_remote").description, toolDef("kb_sparql_remote").inputSchema, async (args) => {
-        const prolog = await runtime.ensureProlog();
-        return runtime.handleSparql(prolog, args);
-    }, runtime);
-    addTool(server, "kb_semantic_advisor", toolDef("kb_semantic_advisor").description, toolDef("kb_semantic_advisor").inputSchema, async (args) => {
-        return runtime.handleKbSemanticAdvisor(args);
-    }, runtime);
-    addTool(server, "kb_upsert", toolDef("kb_upsert").description, toolDef("kb_upsert").inputSchema, async (args) => {
-        const prolog = await runtime.ensureProlog();
-        return runtime.handleKbUpsert(prolog, args);
-    }, runtime);
-    addTool(server, "kb_validate_upsert", toolDef("kb_validate_upsert").description, toolDef("kb_validate_upsert").inputSchema, async (args) => {
-        return runtime.handleKbValidateUpsert(args);
-    }, runtime);
-    addTool(server, "kb_delete", toolDef("kb_delete").description, toolDef("kb_delete").inputSchema, async (args) => {
-        const prolog = await runtime.ensureProlog();
-        return runtime.handleKbDelete(prolog, args);
-    }, runtime);
-    addTool(server, "kb_check", toolDef("kb_check").description, toolDef("kb_check").inputSchema, async (args) => {
-        const prolog = await runtime.ensureProlog();
-        return runtime.handleKbCheck(prolog, args);
-    }, runtime);
-    addTool(server, "kb_model_requirement", toolDef("kb_model_requirement").description, toolDef("kb_model_requirement").inputSchema, async (args) => {
-        const prolog = await runtime.ensureProlog();
-        return runtime.handleKbModelRequirement(prolog, args);
-    }, runtime);
-    addTool(server, "kb_suggest_predicates", toolDef("kb_suggest_predicates").description, toolDef("kb_suggest_predicates").inputSchema, async (args) => {
-        const prolog = await runtime.ensureProlog();
-        return runtime.handleKbSuggestPredicates(prolog, args);
-    }, runtime);
-    addTool(server, "kb_autopilot_generate", toolDef("kb_autopilot_generate").description, toolDef("kb_autopilot_generate").inputSchema, async (args) => {
-        const prolog = await runtime.ensureProlog();
-        return runtime.handleKbAutopilotGenerate(prolog, args);
-    }, runtime);
+    registerConfiguredTools(server, runtime, addTool);
 }