@codebolt/codeboltjs 5.0.2 → 5.0.3

package/dist/tools/knowledge/kg-instance-get.js

@@ -0,0 +1,88 @@
+"use strict";
+/**
+ * KG Instance Get Tool - Gets a knowledge graph instance by ID
+ * Wraps the SDK's knowledgeGraph.getInstance() method
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KGInstanceGetTool = void 0;
+const types_1 = require("../types");
+const base_tool_1 = require("../base-tool");
+const knowledgeGraph_1 = __importDefault(require("../../modules/knowledgeGraph"));
+class KGInstanceGetToolInvocation extends base_tool_1.BaseToolInvocation {
+    constructor(params) {
+        super(params);
+    }
+    async execute() {
+        try {
+            const response = await knowledgeGraph_1.default.getInstance(this.params.instance_id);
+            if (!response.success) {
+                const errorMsg = response.error || response.message || 'Unknown error';
+                return {
+                    llmContent: `Error getting instance: ${errorMsg}`,
+                    returnDisplay: `Error getting instance: ${errorMsg}`,
+                    error: {
+                        message: errorMsg,
+                        type: types_1.ToolErrorType.EXECUTION_FAILED,
+                    },
+                };
+            }
+            const instance = response.data;
+            if (!instance) {
+                return {
+                    llmContent: `Instance with ID "${this.params.instance_id}" not found.`,
+                    returnDisplay: `Instance not found: ${this.params.instance_id}`,
+                    error: {
+                        message: 'Instance not found',
+                        type: types_1.ToolErrorType.EXECUTION_FAILED,
+                    },
+                };
+            }
+            return {
+                llmContent: `Instance "${instance.name}" (ID: ${instance.id}):\n${JSON.stringify(instance, null, 2)}`,
+                returnDisplay: `Retrieved instance: ${instance.name}`,
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+            return {
+                llmContent: `Error getting instance: ${errorMessage}`,
+                returnDisplay: `Error getting instance: ${errorMessage}`,
+                error: {
+                    message: errorMessage,
+                    type: types_1.ToolErrorType.EXECUTION_FAILED,
+                },
+            };
+        }
+    }
+}
+/**
+ * Implementation of the KGInstanceGet tool logic
+ */
+class KGInstanceGetTool extends base_tool_1.BaseDeclarativeTool {
+    constructor() {
+        super(KGInstanceGetTool.Name, 'KGInstanceGet', `Gets a knowledge graph instance by its ID. Returns the full instance details including name, description, and template reference.`, types_1.Kind.Read, {
+            properties: {
+                instance_id: {
+                    description: 'The ID of the instance to retrieve',
+                    type: 'string',
+                },
+            },
+            required: ['instance_id'],
+            type: 'object',
+        });
+    }
+    validateToolParamValues(params) {
+        if (!params.instance_id || params.instance_id.trim() === '') {
+            return "The 'instance_id' parameter must be non-empty.";
+        }
+        return null;
+    }
+    createInvocation(params) {
+        return new KGInstanceGetToolInvocation(params);
+    }
+}
+exports.KGInstanceGetTool = KGInstanceGetTool;
+KGInstanceGetTool.Name = 'kg_instance_get';

package/dist/tools/knowledge/kg-instance-list.d.ts

@@ -0,0 +1,23 @@
+/**
+ * KG Instance List Tool - Lists knowledge graph instances
+ * Wraps the SDK's knowledgeGraph.listInstances() method
+ */
+import type { ToolInvocation, ToolResult } from '../types';
+import { BaseDeclarativeTool } from '../base-tool';
+/**
+ * Parameters for the KGInstanceList tool
+ */
+export interface KGInstanceListToolParams {
+    /**
+     * Optional template ID to filter instances by
+     */
+    template_id?: string;
+}
+/**
+ * Implementation of the KGInstanceList tool logic
+ */
+export declare class KGInstanceListTool extends BaseDeclarativeTool<KGInstanceListToolParams, ToolResult> {
+    static readonly Name: string;
+    constructor();
+    protected createInvocation(params: KGInstanceListToolParams): ToolInvocation<KGInstanceListToolParams, ToolResult>;
+}

package/dist/tools/knowledge/kg-instance-list.js

@@ -0,0 +1,78 @@
+"use strict";
+/**
+ * KG Instance List Tool - Lists knowledge graph instances
+ * Wraps the SDK's knowledgeGraph.listInstances() method
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KGInstanceListTool = void 0;
+const types_1 = require("../types");
+const base_tool_1 = require("../base-tool");
+const knowledgeGraph_1 = __importDefault(require("../../modules/knowledgeGraph"));
+class KGInstanceListToolInvocation extends base_tool_1.BaseToolInvocation {
+    constructor(params) {
+        super(params);
+    }
+    async execute() {
+        try {
+            const response = await knowledgeGraph_1.default.listInstances(this.params.template_id);
+            if (!response.success) {
+                const errorMsg = response.error || response.message || 'Unknown error';
+                return {
+                    llmContent: `Error listing instances: ${errorMsg}`,
+                    returnDisplay: `Error listing instances: ${errorMsg}`,
+                    error: {
+                        message: errorMsg,
+                        type: types_1.ToolErrorType.EXECUTION_FAILED,
+                    },
+                };
+            }
+            const instances = response.data || [];
+            const instanceList = instances.map(i => `- ${i.name} (ID: ${i.id}, Template: ${i.templateId})`).join('\n');
+            const filterInfo = this.params.template_id
+                ? ` (filtered by template: ${this.params.template_id})`
+                : '';
+            return {
+                llmContent: instances.length > 0
+                    ? `Found ${instances.length} instance(s)${filterInfo}:\n${instanceList}\n\nFull data: ${JSON.stringify(instances, null, 2)}`
+                    : `No instances found${filterInfo}.`,
+                returnDisplay: `Listed ${instances.length} instance(s)`,
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+            return {
+                llmContent: `Error listing instances: ${errorMessage}`,
+                returnDisplay: `Error listing instances: ${errorMessage}`,
+                error: {
+                    message: errorMessage,
+                    type: types_1.ToolErrorType.EXECUTION_FAILED,
+                },
+            };
+        }
+    }
+}
+/**
+ * Implementation of the KGInstanceList tool logic
+ */
+class KGInstanceListTool extends base_tool_1.BaseDeclarativeTool {
+    constructor() {
+        super(KGInstanceListTool.Name, 'KGInstanceList', `Lists knowledge graph instances, optionally filtered by template ID. Returns information about all matching instances.`, types_1.Kind.Read, {
+            properties: {
+                template_id: {
+                    description: 'Optional template ID to filter instances by',
+                    type: 'string',
+                },
+            },
+            required: [],
+            type: 'object',
+        });
+    }
+    createInvocation(params) {
+        return new KGInstanceListToolInvocation(params);
+    }
+}
+exports.KGInstanceListTool = KGInstanceListTool;
+KGInstanceListTool.Name = 'kg_instance_list';

package/dist/tools/knowledge/kg-record-add.d.ts

@@ -0,0 +1,40 @@
+/**
+ * KG Record Add Tool - Adds a memory record to a knowledge graph instance
+ * Wraps the SDK's knowledgeGraph.addMemoryRecord() method
+ */
+import type { ToolInvocation, ToolResult } from '../types';
+import { BaseDeclarativeTool } from '../base-tool';
+/**
+ * Parameters for the KGRecordAdd tool
+ */
+export interface KGRecordAddToolParams {
+    /**
+     * The ID of the instance to add the record to
+     */
+    instance_id: string;
+    /**
+     * The kind/type of the record (must match a record_kind in the template)
+     */
+    kind: string;
+    /**
+     * The attributes/data of the record
+     */
+    attributes: Record<string, any>;
+    /**
+     * Optional: Start of validity period (ISO date string)
+     */
+    valid_from?: string;
+    /**
+     * Optional: End of validity period (ISO date string)
+     */
+    valid_to?: string;
+}
+/**
+ * Implementation of the KGRecordAdd tool logic
+ */
+export declare class KGRecordAddTool extends BaseDeclarativeTool<KGRecordAddToolParams, ToolResult> {
+    static readonly Name: string;
+    constructor();
+    protected validateToolParamValues(params: KGRecordAddToolParams): string | null;
+    protected createInvocation(params: KGRecordAddToolParams): ToolInvocation<KGRecordAddToolParams, ToolResult>;
+}

package/dist/tools/knowledge/kg-record-add.js

@@ -0,0 +1,106 @@
+"use strict";
+/**
+ * KG Record Add Tool - Adds a memory record to a knowledge graph instance
+ * Wraps the SDK's knowledgeGraph.addMemoryRecord() method
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KGRecordAddTool = void 0;
+const types_1 = require("../types");
+const base_tool_1 = require("../base-tool");
+const knowledgeGraph_1 = __importDefault(require("../../modules/knowledgeGraph"));
+class KGRecordAddToolInvocation extends base_tool_1.BaseToolInvocation {
+    constructor(params) {
+        super(params);
+    }
+    async execute() {
+        try {
+            const record = {
+                kind: this.params.kind,
+                attributes: this.params.attributes,
+                valid_from: this.params.valid_from,
+                valid_to: this.params.valid_to,
+            };
+            const response = await knowledgeGraph_1.default.addMemoryRecord(this.params.instance_id, record);
+            if (!response.success) {
+                const errorMsg = response.error || response.message || 'Unknown error';
+                return {
+                    llmContent: `Error adding memory record: ${errorMsg}`,
+                    returnDisplay: `Error adding memory record: ${errorMsg}`,
+                    error: {
+                        message: errorMsg,
+                        type: types_1.ToolErrorType.EXECUTION_FAILED,
+                    },
+                };
+            }
+            const addedRecord = response.data;
+            return {
+                llmContent: `Successfully added memory record of kind "${this.params.kind}" with ID: ${addedRecord === null || addedRecord === void 0 ? void 0 : addedRecord.id}\n\nRecord data: ${JSON.stringify(addedRecord, null, 2)}`,
+                returnDisplay: `Added memory record: ${addedRecord === null || addedRecord === void 0 ? void 0 : addedRecord.id}`,
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+            return {
+                llmContent: `Error adding memory record: ${errorMessage}`,
+                returnDisplay: `Error adding memory record: ${errorMessage}`,
+                error: {
+                    message: errorMessage,
+                    type: types_1.ToolErrorType.EXECUTION_FAILED,
+                },
+            };
+        }
+    }
+}
+/**
+ * Implementation of the KGRecordAdd tool logic
+ */
+class KGRecordAddTool extends base_tool_1.BaseDeclarativeTool {
+    constructor() {
+        super(KGRecordAddTool.Name, 'KGRecordAdd', `Adds a memory record (node) to a knowledge graph instance. Records represent entities in the knowledge graph with a specific kind and attributes.`, types_1.Kind.Edit, {
+            properties: {
+                instance_id: {
+                    description: 'The ID of the instance to add the record to',
+                    type: 'string',
+                },
+                kind: {
+                    description: 'The kind/type of the record (must match a record_kind in the template)',
+                    type: 'string',
+                },
+                attributes: {
+                    description: 'The attributes/data of the record as a JSON object',
+                    type: 'object',
+                },
+                valid_from: {
+                    description: 'Optional: Start of validity period (ISO date string)',
+                    type: 'string',
+                },
+                valid_to: {
+                    description: 'Optional: End of validity period (ISO date string)',
+                    type: 'string',
+                },
+            },
+            required: ['instance_id', 'kind', 'attributes'],
+            type: 'object',
+        });
+    }
+    validateToolParamValues(params) {
+        if (!params.instance_id || params.instance_id.trim() === '') {
+            return "The 'instance_id' parameter must be non-empty.";
+        }
+        if (!params.kind || params.kind.trim() === '') {
+            return "The 'kind' parameter must be non-empty.";
+        }
+        if (!params.attributes || typeof params.attributes !== 'object') {
+            return "The 'attributes' parameter must be an object.";
+        }
+        return null;
+    }
+    createInvocation(params) {
+        return new KGRecordAddToolInvocation(params);
+    }
+}
+exports.KGRecordAddTool = KGRecordAddTool;
+KGRecordAddTool.Name = 'kg_record_add';

package/dist/tools/knowledge/kg-record-list.d.ts

@@ -0,0 +1,36 @@
+/**
+ * KG Record List Tool - Lists memory records in a knowledge graph instance
+ * Wraps the SDK's knowledgeGraph.listMemoryRecords() method
+ */
+import type { ToolInvocation, ToolResult } from '../types';
+import { BaseDeclarativeTool } from '../base-tool';
+/**
+ * Parameters for the KGRecordList tool
+ */
+export interface KGRecordListToolParams {
+    /**
+     * The ID of the instance to list records from
+     */
+    instance_id: string;
+    /**
+     * Optional: Filter by record kind
+     */
+    kind?: string;
+    /**
+     * Optional: Maximum number of records to return
+     */
+    limit?: number;
+    /**
+     * Optional: Number of records to skip (for pagination)
+     */
+    offset?: number;
+}
+/**
+ * Implementation of the KGRecordList tool logic
+ */
+export declare class KGRecordListTool extends BaseDeclarativeTool<KGRecordListToolParams, ToolResult> {
+    static readonly Name: string;
+    constructor();
+    protected validateToolParamValues(params: KGRecordListToolParams): string | null;
+    protected createInvocation(params: KGRecordListToolParams): ToolInvocation<KGRecordListToolParams, ToolResult>;
+}

package/dist/tools/knowledge/kg-record-list.js

@@ -0,0 +1,114 @@
+"use strict";
+/**
+ * KG Record List Tool - Lists memory records in a knowledge graph instance
+ * Wraps the SDK's knowledgeGraph.listMemoryRecords() method
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KGRecordListTool = void 0;
+const types_1 = require("../types");
+const base_tool_1 = require("../base-tool");
+const knowledgeGraph_1 = __importDefault(require("../../modules/knowledgeGraph"));
+class KGRecordListToolInvocation extends base_tool_1.BaseToolInvocation {
+    constructor(params) {
+        super(params);
+    }
+    async execute() {
+        try {
+            const filters = {};
+            if (this.params.kind)
+                filters.kind = this.params.kind;
+            if (this.params.limit !== undefined)
+                filters.limit = this.params.limit;
+            if (this.params.offset !== undefined)
+                filters.offset = this.params.offset;
+            const response = await knowledgeGraph_1.default.listMemoryRecords(this.params.instance_id, filters);
+            if (!response.success) {
+                const errorMsg = response.error || response.message || 'Unknown error';
+                return {
+                    llmContent: `Error listing memory records: ${errorMsg}`,
+                    returnDisplay: `Error listing memory records: ${errorMsg}`,
+                    error: {
+                        message: errorMsg,
+                        type: types_1.ToolErrorType.EXECUTION_FAILED,
+                    },
+                };
+            }
+            const records = response.data || [];
+            const recordList = records.map(r => `- ${r.kind}: ${r.id} (${JSON.stringify(r.attributes)})`).join('\n');
+            const filterInfo = [];
+            if (this.params.kind)
+                filterInfo.push(`kind: ${this.params.kind}`);
+            if (this.params.limit !== undefined)
+                filterInfo.push(`limit: ${this.params.limit}`);
+            if (this.params.offset !== undefined)
+                filterInfo.push(`offset: ${this.params.offset}`);
+            const filterStr = filterInfo.length > 0 ? ` (${filterInfo.join(', ')})` : '';
+            return {
+                llmContent: records.length > 0
+                    ? `Found ${records.length} memory record(s) in instance ${this.params.instance_id}${filterStr}:\n${recordList}\n\nFull data: ${JSON.stringify(records, null, 2)}`
+                    : `No memory records found in instance ${this.params.instance_id}${filterStr}.`,
+                returnDisplay: `Listed ${records.length} memory record(s)`,
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+            return {
+                llmContent: `Error listing memory records: ${errorMessage}`,
+                returnDisplay: `Error listing memory records: ${errorMessage}`,
+                error: {
+                    message: errorMessage,
+                    type: types_1.ToolErrorType.EXECUTION_FAILED,
+                },
+            };
+        }
+    }
+}
+/**
+ * Implementation of the KGRecordList tool logic
+ */
+class KGRecordListTool extends base_tool_1.BaseDeclarativeTool {
+    constructor() {
+        super(KGRecordListTool.Name, 'KGRecordList', `Lists memory records in a knowledge graph instance. Can filter by record kind and supports pagination with limit and offset parameters.`, types_1.Kind.Read, {
+            properties: {
+                instance_id: {
+                    description: 'The ID of the instance to list records from',
+                    type: 'string',
+                },
+                kind: {
+                    description: 'Optional: Filter by record kind',
+                    type: 'string',
+                },
+                limit: {
+                    description: 'Optional: Maximum number of records to return',
+                    type: 'number',
+                },
+                offset: {
+                    description: 'Optional: Number of records to skip (for pagination)',
+                    type: 'number',
+                },
+            },
+            required: ['instance_id'],
+            type: 'object',
+        });
+    }
+    validateToolParamValues(params) {
+        if (!params.instance_id || params.instance_id.trim() === '') {
+            return "The 'instance_id' parameter must be non-empty.";
+        }
+        if (params.limit !== undefined && params.limit < 0) {
+            return "The 'limit' parameter must be non-negative.";
+        }
+        if (params.offset !== undefined && params.offset < 0) {
+            return "The 'offset' parameter must be non-negative.";
+        }
+        return null;
+    }
+    createInvocation(params) {
+        return new KGRecordListToolInvocation(params);
+    }
+}
+exports.KGRecordListTool = KGRecordListTool;
+KGRecordListTool.Name = 'kg_record_list';

package/dist/tools/knowledge/kg-template-create.d.ts

@@ -0,0 +1,37 @@
+/**
+ * KG Template Create Tool - Creates a new knowledge graph instance template
+ * Wraps the SDK's knowledgeGraph.createInstanceTemplate() method
+ */
+import type { ToolInvocation, ToolResult } from '../types';
+import { BaseDeclarativeTool } from '../base-tool';
+import type { KGRecordKind, KGEdgeType } from '../../types/knowledgeGraph';
+/**
+ * Parameters for the KGTemplateCreate tool
+ */
+export interface KGTemplateCreateToolParams {
+    /**
+     * The name of the template
+     */
+    name: string;
+    /**
+     * Optional description of the template
+     */
+    description?: string;
+    /**
+     * Array of record kinds defining the node types in the graph
+     */
+    record_kinds: KGRecordKind[];
+    /**
+     * Array of edge types defining the relationships in the graph
+     */
+    edge_types: KGEdgeType[];
+}
+/**
+ * Implementation of the KGTemplateCreate tool logic
+ */
+export declare class KGTemplateCreateTool extends BaseDeclarativeTool<KGTemplateCreateToolParams, ToolResult> {
+    static readonly Name: string;
+    constructor();
+    protected validateToolParamValues(params: KGTemplateCreateToolParams): string | null;
+    protected createInvocation(params: KGTemplateCreateToolParams): ToolInvocation<KGTemplateCreateToolParams, ToolResult>;
+}

package/dist/tools/knowledge/kg-template-create.js

@@ -0,0 +1,124 @@
+"use strict";
+/**
+ * KG Template Create Tool - Creates a new knowledge graph instance template
+ * Wraps the SDK's knowledgeGraph.createInstanceTemplate() method
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KGTemplateCreateTool = void 0;
+const types_1 = require("../types");
+const base_tool_1 = require("../base-tool");
+const knowledgeGraph_1 = __importDefault(require("../../modules/knowledgeGraph"));
+class KGTemplateCreateToolInvocation extends base_tool_1.BaseToolInvocation {
+    constructor(params) {
+        super(params);
+    }
+    async execute() {
+        try {
+            const config = {
+                name: this.params.name,
+                description: this.params.description,
+                record_kinds: this.params.record_kinds,
+                edge_types: this.params.edge_types,
+            };
+            const response = await knowledgeGraph_1.default.createInstanceTemplate(config);
+            if (!response.success) {
+                const errorMsg = response.error || response.message || 'Unknown error';
+                return {
+                    llmContent: `Error creating instance template: ${errorMsg}`,
+                    returnDisplay: `Error creating instance template: ${errorMsg}`,
+                    error: {
+                        message: errorMsg,
+                        type: types_1.ToolErrorType.EXECUTION_FAILED,
+                    },
+                };
+            }
+            const template = response.data;
+            return {
+                llmContent: `Successfully created instance template "${this.params.name}" with ID: ${template === null || template === void 0 ? void 0 : template.id}`,
+                returnDisplay: `Created instance template: ${this.params.name}`,
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+            return {
+                llmContent: `Error creating instance template: ${errorMessage}`,
+                returnDisplay: `Error creating instance template: ${errorMessage}`,
+                error: {
+                    message: errorMessage,
+                    type: types_1.ToolErrorType.EXECUTION_FAILED,
+                },
+            };
+        }
+    }
+}
+/**
+ * Implementation of the KGTemplateCreate tool logic
+ */
+class KGTemplateCreateTool extends base_tool_1.BaseDeclarativeTool {
+    constructor() {
+        super(KGTemplateCreateTool.Name, 'KGTemplateCreate', `Creates a new knowledge graph instance template. Templates define the schema for knowledge graph instances including the types of records (nodes) and edges (relationships) that can be stored.`, types_1.Kind.Edit, {
+            properties: {
+                name: {
+                    description: 'The name of the template',
+                    type: 'string',
+                },
+                description: {
+                    description: 'Optional description of the template',
+                    type: 'string',
+                },
+                record_kinds: {
+                    description: 'Array of record kinds defining the node types in the graph',
+                    type: 'array',
+                    items: {
+                        type: 'object',
+                        properties: {
+                            name: { type: 'string' },
+                            label: { type: 'string' },
+                            description: { type: 'string' },
+                            attributes: { type: 'object' },
+                        },
+                        required: ['name', 'label', 'attributes'],
+                    },
+                },
+                edge_types: {
+                    description: 'Array of edge types defining the relationships in the graph',
+                    type: 'array',
+                    items: {
+                        type: 'object',
+                        properties: {
+                            name: { type: 'string' },
+                            label: { type: 'string' },
+                            description: { type: 'string' },
+                            from_kinds: { type: 'array', items: { type: 'string' } },
+                            to_kinds: { type: 'array', items: { type: 'string' } },
+                            attributes: { type: 'object' },
+                        },
+                        required: ['name', 'label', 'from_kinds', 'to_kinds'],
+                    },
+                },
+            },
+            required: ['name', 'record_kinds', 'edge_types'],
+            type: 'object',
+        });
+    }
+    validateToolParamValues(params) {
+        if (!params.name || params.name.trim() === '') {
+            return "The 'name' parameter must be non-empty.";
+        }
+        if (!params.record_kinds || params.record_kinds.length === 0) {
+            return "The 'record_kinds' parameter must contain at least one record kind.";
+        }
+        if (!params.edge_types || params.edge_types.length === 0) {
+            return "The 'edge_types' parameter must contain at least one edge type.";
+        }
+        return null;
+    }
+    createInvocation(params) {
+        return new KGTemplateCreateToolInvocation(params);
+    }
+}
+exports.KGTemplateCreateTool = KGTemplateCreateTool;
+KGTemplateCreateTool.Name = 'kg_template_create';

package/dist/tools/knowledge/kg-template-delete.d.ts

@@ -0,0 +1,24 @@
+/**
+ * KG Template Delete Tool - Deletes a knowledge graph instance template
+ * Wraps the SDK's knowledgeGraph.deleteInstanceTemplate() method
+ */
+import type { ToolInvocation, ToolResult } from '../types';
+import { BaseDeclarativeTool } from '../base-tool';
+/**
+ * Parameters for the KGTemplateDelete tool
+ */
+export interface KGTemplateDeleteToolParams {
+    /**
+     * The ID of the template to delete
+     */
+    template_id: string;
+}
+/**
+ * Implementation of the KGTemplateDelete tool logic
+ */
+export declare class KGTemplateDeleteTool extends BaseDeclarativeTool<KGTemplateDeleteToolParams, ToolResult> {
+    static readonly Name: string;
+    constructor();
+    protected validateToolParamValues(params: KGTemplateDeleteToolParams): string | null;
+    protected createInvocation(params: KGTemplateDeleteToolParams): ToolInvocation<KGTemplateDeleteToolParams, ToolResult>;
+}