@codebolt/codeboltjs 5.0.2 → 5.0.3

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

@@ -0,0 +1,77 @@
+"use strict";
+/**
+ * KG Template Delete Tool - Deletes a knowledge graph instance template
+ * Wraps the SDK's knowledgeGraph.deleteInstanceTemplate() method
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KGTemplateDeleteTool = void 0;
+const types_1 = require("../types");
+const base_tool_1 = require("../base-tool");
+const knowledgeGraph_1 = __importDefault(require("../../modules/knowledgeGraph"));
+class KGTemplateDeleteToolInvocation extends base_tool_1.BaseToolInvocation {
+    constructor(params) {
+        super(params);
+    }
+    async execute() {
+        try {
+            const response = await knowledgeGraph_1.default.deleteInstanceTemplate(this.params.template_id);
+            if (!response.success) {
+                const errorMsg = response.error || response.message || 'Unknown error';
+                return {
+                    llmContent: `Error deleting instance template: ${errorMsg}`,
+                    returnDisplay: `Error deleting instance template: ${errorMsg}`,
+                    error: {
+                        message: errorMsg,
+                        type: types_1.ToolErrorType.EXECUTION_FAILED,
+                    },
+                };
+            }
+            return {
+                llmContent: `Successfully deleted instance template with ID: ${this.params.template_id}`,
+                returnDisplay: `Deleted instance template: ${this.params.template_id}`,
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+            return {
+                llmContent: `Error deleting instance template: ${errorMessage}`,
+                returnDisplay: `Error deleting instance template: ${errorMessage}`,
+                error: {
+                    message: errorMessage,
+                    type: types_1.ToolErrorType.EXECUTION_FAILED,
+                },
+            };
+        }
+    }
+}
+/**
+ * Implementation of the KGTemplateDelete tool logic
+ */
+class KGTemplateDeleteTool extends base_tool_1.BaseDeclarativeTool {
+    constructor() {
+        super(KGTemplateDeleteTool.Name, 'KGTemplateDelete', `Deletes a knowledge graph instance template by its ID. This will permanently remove the template. Use with caution.`, types_1.Kind.Delete, {
+            properties: {
+                template_id: {
+                    description: 'The ID of the template to delete',
+                    type: 'string',
+                },
+            },
+            required: ['template_id'],
+            type: 'object',
+        });
+    }
+    validateToolParamValues(params) {
+        if (!params.template_id || params.template_id.trim() === '') {
+            return "The 'template_id' parameter must be non-empty.";
+        }
+        return null;
+    }
+    createInvocation(params) {
+        return new KGTemplateDeleteToolInvocation(params);
+    }
+}
+exports.KGTemplateDeleteTool = KGTemplateDeleteTool;
+KGTemplateDeleteTool.Name = 'kg_template_delete';

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

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

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

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

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

@@ -0,0 +1,19 @@
+/**
+ * KG Template List Tool - Lists all knowledge graph instance templates
+ * Wraps the SDK's knowledgeGraph.listInstanceTemplates() method
+ */
+import type { ToolInvocation, ToolResult } from '../types';
+import { BaseDeclarativeTool } from '../base-tool';
+/**
+ * Parameters for the KGTemplateList tool
+ */
+export interface KGTemplateListToolParams {
+}
+/**
+ * Implementation of the KGTemplateList tool logic
+ */
+export declare class KGTemplateListTool extends BaseDeclarativeTool<KGTemplateListToolParams, ToolResult> {
+    static readonly Name: string;
+    constructor();
+    protected createInvocation(params: KGTemplateListToolParams): ToolInvocation<KGTemplateListToolParams, ToolResult>;
+}

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

@@ -0,0 +1,70 @@
+"use strict";
+/**
+ * KG Template List Tool - Lists all knowledge graph instance templates
+ * Wraps the SDK's knowledgeGraph.listInstanceTemplates() method
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KGTemplateListTool = void 0;
+const types_1 = require("../types");
+const base_tool_1 = require("../base-tool");
+const knowledgeGraph_1 = __importDefault(require("../../modules/knowledgeGraph"));
+class KGTemplateListToolInvocation extends base_tool_1.BaseToolInvocation {
+    constructor(params) {
+        super(params);
+    }
+    async execute() {
+        try {
+            const response = await knowledgeGraph_1.default.listInstanceTemplates();
+            if (!response.success) {
+                const errorMsg = response.error || response.message || 'Unknown error';
+                return {
+                    llmContent: `Error listing instance templates: ${errorMsg}`,
+                    returnDisplay: `Error listing instance templates: ${errorMsg}`,
+                    error: {
+                        message: errorMsg,
+                        type: types_1.ToolErrorType.EXECUTION_FAILED,
+                    },
+                };
+            }
+            const templates = response.data || [];
+            const templateList = templates.map(t => `- ${t.name} (ID: ${t.id})`).join('\n');
+            return {
+                llmContent: templates.length > 0
+                    ? `Found ${templates.length} instance template(s):\n${templateList}\n\nFull data: ${JSON.stringify(templates, null, 2)}`
+                    : 'No instance templates found.',
+                returnDisplay: `Listed ${templates.length} instance template(s)`,
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+            return {
+                llmContent: `Error listing instance templates: ${errorMessage}`,
+                returnDisplay: `Error listing instance templates: ${errorMessage}`,
+                error: {
+                    message: errorMessage,
+                    type: types_1.ToolErrorType.EXECUTION_FAILED,
+                },
+            };
+        }
+    }
+}
+/**
+ * Implementation of the KGTemplateList tool logic
+ */
+class KGTemplateListTool extends base_tool_1.BaseDeclarativeTool {
+    constructor() {
+        super(KGTemplateListTool.Name, 'KGTemplateList', `Lists all knowledge graph instance templates. Returns information about all available templates including their names, IDs, and schemas.`, types_1.Kind.Read, {
+            properties: {},
+            required: [],
+            type: 'object',
+        });
+    }
+    createInvocation(params) {
+        return new KGTemplateListToolInvocation(params);
+    }
+}
+exports.KGTemplateListTool = KGTemplateListTool;
+KGTemplateListTool.Name = 'kg_template_list';

package/dist/tools/knowledgeGraph/index.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Knowledge Graph Tools
+ *
+ * Tools for managing knowledge graph operations including templates, instances,
+ * memory records, edges, view templates, and views.
+ */
+export { KGCreateInstanceTemplateTool } from './kg-create-instance-template';
+export { KGGetInstanceTemplateTool } from './kg-get-instance-template';
+export { KGListInstanceTemplatesTool } from './kg-list-instance-templates';
+export { KGUpdateInstanceTemplateTool } from './kg-update-instance-template';
+export { KGDeleteInstanceTemplateTool } from './kg-delete-instance-template';
+export { KGCreateInstanceTool } from './kg-create-instance';
+export { KGGetInstanceTool } from './kg-get-instance';
+export { KGListInstancesTool } from './kg-list-instances';
+export { KGDeleteInstanceTool } from './kg-delete-instance';
+export { KGAddMemoryRecordTool } from './kg-add-memory-record';
+export { KGAddMemoryRecordsTool } from './kg-add-memory-records';
+export { KGGetMemoryRecordTool } from './kg-get-memory-record';
+export { KGListMemoryRecordsTool } from './kg-list-memory-records';
+export { KGUpdateMemoryRecordTool } from './kg-update-memory-record';
+export { KGDeleteMemoryRecordTool } from './kg-delete-memory-record';
+export { KGAddEdgeTool } from './kg-add-edge';
+export { KGAddEdgesTool } from './kg-add-edges';
+export { KGListEdgesTool } from './kg-list-edges';
+export { KGDeleteEdgeTool } from './kg-delete-edge';
+export { KGCreateViewTemplateTool } from './kg-create-view-template';
+export { KGGetViewTemplateTool } from './kg-get-view-template';
+export { KGListViewTemplatesTool } from './kg-list-view-templates';
+export { KGUpdateViewTemplateTool } from './kg-update-view-template';
+export { KGDeleteViewTemplateTool } from './kg-delete-view-template';
+export { KGCreateViewTool } from './kg-create-view';
+export { KGListViewsTool } from './kg-list-views';
+export { KGExecuteViewTool } from './kg-execute-view';
+export { KGDeleteViewTool } from './kg-delete-view';
+import { KGCreateInstanceTemplateTool } from './kg-create-instance-template';
+import { KGGetInstanceTemplateTool } from './kg-get-instance-template';
+import { KGListInstanceTemplatesTool } from './kg-list-instance-templates';
+import { KGUpdateInstanceTemplateTool } from './kg-update-instance-template';
+import { KGDeleteInstanceTemplateTool } from './kg-delete-instance-template';
+import { KGCreateInstanceTool } from './kg-create-instance';
+import { KGGetInstanceTool } from './kg-get-instance';
+import { KGListInstancesTool } from './kg-list-instances';
+import { KGDeleteInstanceTool } from './kg-delete-instance';
+import { KGAddMemoryRecordTool } from './kg-add-memory-record';
+import { KGAddMemoryRecordsTool } from './kg-add-memory-records';
+import { KGGetMemoryRecordTool } from './kg-get-memory-record';
+import { KGListMemoryRecordsTool } from './kg-list-memory-records';
+import { KGUpdateMemoryRecordTool } from './kg-update-memory-record';
+import { KGDeleteMemoryRecordTool } from './kg-delete-memory-record';
+import { KGAddEdgeTool } from './kg-add-edge';
+import { KGAddEdgesTool } from './kg-add-edges';
+import { KGListEdgesTool } from './kg-list-edges';
+import { KGDeleteEdgeTool } from './kg-delete-edge';
+import { KGCreateViewTemplateTool } from './kg-create-view-template';
+import { KGGetViewTemplateTool } from './kg-get-view-template';
+import { KGListViewTemplatesTool } from './kg-list-view-templates';
+import { KGUpdateViewTemplateTool } from './kg-update-view-template';
+import { KGDeleteViewTemplateTool } from './kg-delete-view-template';
+import { KGCreateViewTool } from './kg-create-view';
+import { KGListViewsTool } from './kg-list-views';
+import { KGExecuteViewTool } from './kg-execute-view';
+import { KGDeleteViewTool } from './kg-delete-view';
+/**
+ * Array of all knowledge graph tools
+ */
+export declare const knowledgeGraphTools: (KGCreateInstanceTemplateTool | KGGetInstanceTemplateTool | KGListInstanceTemplatesTool | KGUpdateInstanceTemplateTool | KGDeleteInstanceTemplateTool | KGCreateInstanceTool | KGGetInstanceTool | KGListInstancesTool | KGDeleteInstanceTool | KGAddMemoryRecordTool | KGAddMemoryRecordsTool | KGGetMemoryRecordTool | KGListMemoryRecordsTool | KGUpdateMemoryRecordTool | KGDeleteMemoryRecordTool | KGAddEdgeTool | KGAddEdgesTool | KGListEdgesTool | KGDeleteEdgeTool | KGCreateViewTemplateTool | KGGetViewTemplateTool | KGListViewTemplatesTool | KGUpdateViewTemplateTool | KGDeleteViewTemplateTool | KGCreateViewTool | KGListViewsTool | KGExecuteViewTool | KGDeleteViewTool)[];

package/dist/tools/knowledgeGraph/index.js

@@ -0,0 +1,139 @@
+"use strict";
+/**
+ * Knowledge Graph Tools
+ *
+ * Tools for managing knowledge graph operations including templates, instances,
+ * memory records, edges, view templates, and views.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.knowledgeGraphTools = exports.KGDeleteViewTool = exports.KGExecuteViewTool = exports.KGListViewsTool = exports.KGCreateViewTool = exports.KGDeleteViewTemplateTool = exports.KGUpdateViewTemplateTool = exports.KGListViewTemplatesTool = exports.KGGetViewTemplateTool = exports.KGCreateViewTemplateTool = exports.KGDeleteEdgeTool = exports.KGListEdgesTool = exports.KGAddEdgesTool = exports.KGAddEdgeTool = exports.KGDeleteMemoryRecordTool = exports.KGUpdateMemoryRecordTool = exports.KGListMemoryRecordsTool = exports.KGGetMemoryRecordTool = exports.KGAddMemoryRecordsTool = exports.KGAddMemoryRecordTool = exports.KGDeleteInstanceTool = exports.KGListInstancesTool = exports.KGGetInstanceTool = exports.KGCreateInstanceTool = exports.KGDeleteInstanceTemplateTool = exports.KGUpdateInstanceTemplateTool = exports.KGListInstanceTemplatesTool = exports.KGGetInstanceTemplateTool = exports.KGCreateInstanceTemplateTool = void 0;
+// Instance Template Operations
+var kg_create_instance_template_1 = require("./kg-create-instance-template");
+Object.defineProperty(exports, "KGCreateInstanceTemplateTool", { enumerable: true, get: function () { return kg_create_instance_template_1.KGCreateInstanceTemplateTool; } });
+var kg_get_instance_template_1 = require("./kg-get-instance-template");
+Object.defineProperty(exports, "KGGetInstanceTemplateTool", { enumerable: true, get: function () { return kg_get_instance_template_1.KGGetInstanceTemplateTool; } });
+var kg_list_instance_templates_1 = require("./kg-list-instance-templates");
+Object.defineProperty(exports, "KGListInstanceTemplatesTool", { enumerable: true, get: function () { return kg_list_instance_templates_1.KGListInstanceTemplatesTool; } });
+var kg_update_instance_template_1 = require("./kg-update-instance-template");
+Object.defineProperty(exports, "KGUpdateInstanceTemplateTool", { enumerable: true, get: function () { return kg_update_instance_template_1.KGUpdateInstanceTemplateTool; } });
+var kg_delete_instance_template_1 = require("./kg-delete-instance-template");
+Object.defineProperty(exports, "KGDeleteInstanceTemplateTool", { enumerable: true, get: function () { return kg_delete_instance_template_1.KGDeleteInstanceTemplateTool; } });
+// Instance Operations
+var kg_create_instance_1 = require("./kg-create-instance");
+Object.defineProperty(exports, "KGCreateInstanceTool", { enumerable: true, get: function () { return kg_create_instance_1.KGCreateInstanceTool; } });
+var kg_get_instance_1 = require("./kg-get-instance");
+Object.defineProperty(exports, "KGGetInstanceTool", { enumerable: true, get: function () { return kg_get_instance_1.KGGetInstanceTool; } });
+var kg_list_instances_1 = require("./kg-list-instances");
+Object.defineProperty(exports, "KGListInstancesTool", { enumerable: true, get: function () { return kg_list_instances_1.KGListInstancesTool; } });
+var kg_delete_instance_1 = require("./kg-delete-instance");
+Object.defineProperty(exports, "KGDeleteInstanceTool", { enumerable: true, get: function () { return kg_delete_instance_1.KGDeleteInstanceTool; } });
+// Memory Record Operations
+var kg_add_memory_record_1 = require("./kg-add-memory-record");
+Object.defineProperty(exports, "KGAddMemoryRecordTool", { enumerable: true, get: function () { return kg_add_memory_record_1.KGAddMemoryRecordTool; } });
+var kg_add_memory_records_1 = require("./kg-add-memory-records");
+Object.defineProperty(exports, "KGAddMemoryRecordsTool", { enumerable: true, get: function () { return kg_add_memory_records_1.KGAddMemoryRecordsTool; } });
+var kg_get_memory_record_1 = require("./kg-get-memory-record");
+Object.defineProperty(exports, "KGGetMemoryRecordTool", { enumerable: true, get: function () { return kg_get_memory_record_1.KGGetMemoryRecordTool; } });
+var kg_list_memory_records_1 = require("./kg-list-memory-records");
+Object.defineProperty(exports, "KGListMemoryRecordsTool", { enumerable: true, get: function () { return kg_list_memory_records_1.KGListMemoryRecordsTool; } });
+var kg_update_memory_record_1 = require("./kg-update-memory-record");
+Object.defineProperty(exports, "KGUpdateMemoryRecordTool", { enumerable: true, get: function () { return kg_update_memory_record_1.KGUpdateMemoryRecordTool; } });
+var kg_delete_memory_record_1 = require("./kg-delete-memory-record");
+Object.defineProperty(exports, "KGDeleteMemoryRecordTool", { enumerable: true, get: function () { return kg_delete_memory_record_1.KGDeleteMemoryRecordTool; } });
+// Edge Operations
+var kg_add_edge_1 = require("./kg-add-edge");
+Object.defineProperty(exports, "KGAddEdgeTool", { enumerable: true, get: function () { return kg_add_edge_1.KGAddEdgeTool; } });
+var kg_add_edges_1 = require("./kg-add-edges");
+Object.defineProperty(exports, "KGAddEdgesTool", { enumerable: true, get: function () { return kg_add_edges_1.KGAddEdgesTool; } });
+var kg_list_edges_1 = require("./kg-list-edges");
+Object.defineProperty(exports, "KGListEdgesTool", { enumerable: true, get: function () { return kg_list_edges_1.KGListEdgesTool; } });
+var kg_delete_edge_1 = require("./kg-delete-edge");
+Object.defineProperty(exports, "KGDeleteEdgeTool", { enumerable: true, get: function () { return kg_delete_edge_1.KGDeleteEdgeTool; } });
+// View Template Operations
+var kg_create_view_template_1 = require("./kg-create-view-template");
+Object.defineProperty(exports, "KGCreateViewTemplateTool", { enumerable: true, get: function () { return kg_create_view_template_1.KGCreateViewTemplateTool; } });
+var kg_get_view_template_1 = require("./kg-get-view-template");
+Object.defineProperty(exports, "KGGetViewTemplateTool", { enumerable: true, get: function () { return kg_get_view_template_1.KGGetViewTemplateTool; } });
+var kg_list_view_templates_1 = require("./kg-list-view-templates");
+Object.defineProperty(exports, "KGListViewTemplatesTool", { enumerable: true, get: function () { return kg_list_view_templates_1.KGListViewTemplatesTool; } });
+var kg_update_view_template_1 = require("./kg-update-view-template");
+Object.defineProperty(exports, "KGUpdateViewTemplateTool", { enumerable: true, get: function () { return kg_update_view_template_1.KGUpdateViewTemplateTool; } });
+var kg_delete_view_template_1 = require("./kg-delete-view-template");
+Object.defineProperty(exports, "KGDeleteViewTemplateTool", { enumerable: true, get: function () { return kg_delete_view_template_1.KGDeleteViewTemplateTool; } });
+// View Operations
+var kg_create_view_1 = require("./kg-create-view");
+Object.defineProperty(exports, "KGCreateViewTool", { enumerable: true, get: function () { return kg_create_view_1.KGCreateViewTool; } });
+var kg_list_views_1 = require("./kg-list-views");
+Object.defineProperty(exports, "KGListViewsTool", { enumerable: true, get: function () { return kg_list_views_1.KGListViewsTool; } });
+var kg_execute_view_1 = require("./kg-execute-view");
+Object.defineProperty(exports, "KGExecuteViewTool", { enumerable: true, get: function () { return kg_execute_view_1.KGExecuteViewTool; } });
+var kg_delete_view_1 = require("./kg-delete-view");
+Object.defineProperty(exports, "KGDeleteViewTool", { enumerable: true, get: function () { return kg_delete_view_1.KGDeleteViewTool; } });
+// Import all tools
+const kg_create_instance_template_2 = require("./kg-create-instance-template");
+const kg_get_instance_template_2 = require("./kg-get-instance-template");
+const kg_list_instance_templates_2 = require("./kg-list-instance-templates");
+const kg_update_instance_template_2 = require("./kg-update-instance-template");
+const kg_delete_instance_template_2 = require("./kg-delete-instance-template");
+const kg_create_instance_2 = require("./kg-create-instance");
+const kg_get_instance_2 = require("./kg-get-instance");
+const kg_list_instances_2 = require("./kg-list-instances");
+const kg_delete_instance_2 = require("./kg-delete-instance");
+const kg_add_memory_record_2 = require("./kg-add-memory-record");
+const kg_add_memory_records_2 = require("./kg-add-memory-records");
+const kg_get_memory_record_2 = require("./kg-get-memory-record");
+const kg_list_memory_records_2 = require("./kg-list-memory-records");
+const kg_update_memory_record_2 = require("./kg-update-memory-record");
+const kg_delete_memory_record_2 = require("./kg-delete-memory-record");
+const kg_add_edge_2 = require("./kg-add-edge");
+const kg_add_edges_2 = require("./kg-add-edges");
+const kg_list_edges_2 = require("./kg-list-edges");
+const kg_delete_edge_2 = require("./kg-delete-edge");
+const kg_create_view_template_2 = require("./kg-create-view-template");
+const kg_get_view_template_2 = require("./kg-get-view-template");
+const kg_list_view_templates_2 = require("./kg-list-view-templates");
+const kg_update_view_template_2 = require("./kg-update-view-template");
+const kg_delete_view_template_2 = require("./kg-delete-view-template");
+const kg_create_view_2 = require("./kg-create-view");
+const kg_list_views_2 = require("./kg-list-views");
+const kg_execute_view_2 = require("./kg-execute-view");
+const kg_delete_view_2 = require("./kg-delete-view");
+/**
+ * Array of all knowledge graph tools
+ */
+exports.knowledgeGraphTools = [
+    // Instance Template Operations
+    new kg_create_instance_template_2.KGCreateInstanceTemplateTool(),
+    new kg_get_instance_template_2.KGGetInstanceTemplateTool(),
+    new kg_list_instance_templates_2.KGListInstanceTemplatesTool(),
+    new kg_update_instance_template_2.KGUpdateInstanceTemplateTool(),
+    new kg_delete_instance_template_2.KGDeleteInstanceTemplateTool(),
+    // Instance Operations
+    new kg_create_instance_2.KGCreateInstanceTool(),
+    new kg_get_instance_2.KGGetInstanceTool(),
+    new kg_list_instances_2.KGListInstancesTool(),
+    new kg_delete_instance_2.KGDeleteInstanceTool(),
+    // Memory Record Operations
+    new kg_add_memory_record_2.KGAddMemoryRecordTool(),
+    new kg_add_memory_records_2.KGAddMemoryRecordsTool(),
+    new kg_get_memory_record_2.KGGetMemoryRecordTool(),
+    new kg_list_memory_records_2.KGListMemoryRecordsTool(),
+    new kg_update_memory_record_2.KGUpdateMemoryRecordTool(),
+    new kg_delete_memory_record_2.KGDeleteMemoryRecordTool(),
+    // Edge Operations
+    new kg_add_edge_2.KGAddEdgeTool(),
+    new kg_add_edges_2.KGAddEdgesTool(),
+    new kg_list_edges_2.KGListEdgesTool(),
+    new kg_delete_edge_2.KGDeleteEdgeTool(),
+    // View Template Operations
+    new kg_create_view_template_2.KGCreateViewTemplateTool(),
+    new kg_get_view_template_2.KGGetViewTemplateTool(),
+    new kg_list_view_templates_2.KGListViewTemplatesTool(),
+    new kg_update_view_template_2.KGUpdateViewTemplateTool(),
+    new kg_delete_view_template_2.KGDeleteViewTemplateTool(),
+    // View Operations
+    new kg_create_view_2.KGCreateViewTool(),
+    new kg_list_views_2.KGListViewsTool(),
+    new kg_execute_view_2.KGExecuteViewTool(),
+    new kg_delete_view_2.KGDeleteViewTool(),
+];

package/dist/tools/knowledgeGraph/kg-add-edge.d.ts

@@ -0,0 +1,11 @@
+import type { ToolInvocation, ToolResult } from '../types';
+import { BaseDeclarativeTool } from '../base-tool';
+import type { CreateKGEdgeParams } from '../../types/knowledgeGraph';
+export interface KGAddEdgeParams {
+    instanceId: string;
+    edge: CreateKGEdgeParams;
+}
+export declare class KGAddEdgeTool extends BaseDeclarativeTool<KGAddEdgeParams, ToolResult> {
+    constructor();
+    protected createInvocation(params: KGAddEdgeParams): ToolInvocation<KGAddEdgeParams, ToolResult>;
+}

package/dist/tools/knowledgeGraph/kg-add-edge.js

@@ -0,0 +1,56 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KGAddEdgeTool = void 0;
+const types_1 = require("../types");
+const base_tool_1 = require("../base-tool");
+const knowledgeGraph_1 = __importDefault(require("../../modules/knowledgeGraph"));
+class KGAddEdgeInvocation extends base_tool_1.BaseToolInvocation {
+    constructor(params) {
+        super(params);
+    }
+    async execute(_signal) {
+        try {
+            const response = await knowledgeGraph_1.default.addEdge(this.params.instanceId, this.params.edge);
+            if (!response.success) {
+                return {
+                    llmContent: `Error: ${response.error}`,
+                    returnDisplay: `Error: ${response.error}`,
+                    error: { message: response.error || 'Unknown error', type: types_1.ToolErrorType.EXECUTION_FAILED },
+                };
+            }
+            return {
+                llmContent: `Edge added: ${JSON.stringify(response.data)}`,
+                returnDisplay: `Added edge to instance: ${this.params.instanceId}`,
+            };
+        }
+        catch (error) {
+            return {
+                llmContent: `Error: ${error}`,
+                returnDisplay: `Error: ${error}`,
+                error: { message: String(error), type: types_1.ToolErrorType.EXECUTION_FAILED },
+            };
+        }
+    }
+}
+class KGAddEdgeTool extends base_tool_1.BaseDeclarativeTool {
+    constructor() {
+        super('kg_add_edge', 'Add KG Edge', 'Add an edge to a knowledge graph instance', types_1.Kind.Other, {
+            type: 'object',
+            properties: {
+                instanceId: { type: 'string', description: 'Instance ID' },
+                edge: {
+                    type: 'object',
+                    description: 'Edge data',
+                },
+            },
+            required: ['instanceId', 'edge'],
+        });
+    }
+    createInvocation(params) {
+        return new KGAddEdgeInvocation(params);
+    }
+}
+exports.KGAddEdgeTool = KGAddEdgeTool;

package/dist/tools/knowledgeGraph/kg-add-edges.d.ts

@@ -0,0 +1,11 @@
+import type { ToolInvocation, ToolResult } from '../types';
+import { BaseDeclarativeTool } from '../base-tool';
+import type { CreateKGEdgeParams } from '../../types/knowledgeGraph';
+export interface KGAddEdgesParams {
+    instanceId: string;
+    edges: CreateKGEdgeParams[];
+}
+export declare class KGAddEdgesTool extends BaseDeclarativeTool<KGAddEdgesParams, ToolResult> {
+    constructor();
+    protected createInvocation(params: KGAddEdgesParams): ToolInvocation<KGAddEdgesParams, ToolResult>;
+}

package/dist/tools/knowledgeGraph/kg-add-edges.js

@@ -0,0 +1,58 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KGAddEdgesTool = void 0;
+const types_1 = require("../types");
+const base_tool_1 = require("../base-tool");
+const knowledgeGraph_1 = __importDefault(require("../../modules/knowledgeGraph"));
+class KGAddEdgesInvocation extends base_tool_1.BaseToolInvocation {
+    constructor(params) {
+        super(params);
+    }
+    async execute(_signal) {
+        try {
+            const response = await knowledgeGraph_1.default.addEdges(this.params.instanceId, this.params.edges);
+            if (!response.success) {
+                return {
+                    llmContent: `Error: ${response.error}`,
+                    returnDisplay: `Error: ${response.error}`,
+                    error: { message: response.error || 'Unknown error', type: types_1.ToolErrorType.EXECUTION_FAILED },
+                };
+            }
+            const edges = response.data || [];
+            return {
+                llmContent: `Added ${edges.length} edges: ${JSON.stringify(edges)}`,
+                returnDisplay: `Added ${edges.length} edges to instance: ${this.params.instanceId}`,
+            };
+        }
+        catch (error) {
+            return {
+                llmContent: `Error: ${error}`,
+                returnDisplay: `Error: ${error}`,
+                error: { message: String(error), type: types_1.ToolErrorType.EXECUTION_FAILED },
+            };
+        }
+    }
+}
+class KGAddEdgesTool extends base_tool_1.BaseDeclarativeTool {
+    constructor() {
+        super('kg_add_edges', 'Add KG Edges', 'Add multiple edges to a knowledge graph instance', types_1.Kind.Other, {
+            type: 'object',
+            properties: {
+                instanceId: { type: 'string', description: 'Instance ID' },
+                edges: {
+                    type: 'array',
+                    description: 'Array of edge data',
+                    items: { type: 'object' },
+                },
+            },
+            required: ['instanceId', 'edges'],
+        });
+    }
+    createInvocation(params) {
+        return new KGAddEdgesInvocation(params);
+    }
+}
+exports.KGAddEdgesTool = KGAddEdgesTool;

package/dist/tools/knowledgeGraph/kg-add-memory-record.d.ts

@@ -0,0 +1,11 @@
+import type { ToolInvocation, ToolResult } from '../types';
+import { BaseDeclarativeTool } from '../base-tool';
+import type { CreateKGMemoryRecordParams } from '../../types/knowledgeGraph';
+export interface KGAddMemoryRecordParams {
+    instanceId: string;
+    record: CreateKGMemoryRecordParams;
+}
+export declare class KGAddMemoryRecordTool extends BaseDeclarativeTool<KGAddMemoryRecordParams, ToolResult> {
+    constructor();
+    protected createInvocation(params: KGAddMemoryRecordParams): ToolInvocation<KGAddMemoryRecordParams, ToolResult>;
+}