@codebolt/codeboltjs 5.0.2 → 5.0.3

package/dist/tools/knowledgeGraph/kg-delete-view-template.d.ts

@@ -0,0 +1,9 @@
+import type { ToolInvocation, ToolResult } from '../types';
+import { BaseDeclarativeTool } from '../base-tool';
+export interface KGDeleteViewTemplateParams {
+    templateId: string;
+}
+export declare class KGDeleteViewTemplateTool extends BaseDeclarativeTool<KGDeleteViewTemplateParams, ToolResult> {
+    constructor();
+    protected createInvocation(params: KGDeleteViewTemplateParams): ToolInvocation<KGDeleteViewTemplateParams, ToolResult>;
+}

package/dist/tools/knowledgeGraph/kg-delete-view-template.js

@@ -0,0 +1,52 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KGDeleteViewTemplateTool = void 0;
+const types_1 = require("../types");
+const base_tool_1 = require("../base-tool");
+const knowledgeGraph_1 = __importDefault(require("../../modules/knowledgeGraph"));
+class KGDeleteViewTemplateInvocation extends base_tool_1.BaseToolInvocation {
+    constructor(params) {
+        super(params);
+    }
+    async execute(_signal) {
+        try {
+            const response = await knowledgeGraph_1.default.deleteViewTemplate(this.params.templateId);
+            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: `View template deleted: ${this.params.templateId}`,
+                returnDisplay: `Deleted view template: ${this.params.templateId}`,
+            };
+        }
+        catch (error) {
+            return {
+                llmContent: `Error: ${error}`,
+                returnDisplay: `Error: ${error}`,
+                error: { message: String(error), type: types_1.ToolErrorType.EXECUTION_FAILED },
+            };
+        }
+    }
+}
+class KGDeleteViewTemplateTool extends base_tool_1.BaseDeclarativeTool {
+    constructor() {
+        super('kg_delete_view_template', 'Delete KG View Template', 'Delete a view template', types_1.Kind.Other, {
+            type: 'object',
+            properties: {
+                templateId: { type: 'string', description: 'Template ID' },
+            },
+            required: ['templateId'],
+        });
+    }
+    createInvocation(params) {
+        return new KGDeleteViewTemplateInvocation(params);
+    }
+}
+exports.KGDeleteViewTemplateTool = KGDeleteViewTemplateTool;

package/dist/tools/knowledgeGraph/kg-delete-view.d.ts

@@ -0,0 +1,9 @@
+import type { ToolInvocation, ToolResult } from '../types';
+import { BaseDeclarativeTool } from '../base-tool';
+export interface KGDeleteViewParams {
+    viewId: string;
+}
+export declare class KGDeleteViewTool extends BaseDeclarativeTool<KGDeleteViewParams, ToolResult> {
+    constructor();
+    protected createInvocation(params: KGDeleteViewParams): ToolInvocation<KGDeleteViewParams, ToolResult>;
+}

package/dist/tools/knowledgeGraph/kg-delete-view.js

@@ -0,0 +1,52 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KGDeleteViewTool = void 0;
+const types_1 = require("../types");
+const base_tool_1 = require("../base-tool");
+const knowledgeGraph_1 = __importDefault(require("../../modules/knowledgeGraph"));
+class KGDeleteViewInvocation extends base_tool_1.BaseToolInvocation {
+    constructor(params) {
+        super(params);
+    }
+    async execute(_signal) {
+        try {
+            const response = await knowledgeGraph_1.default.deleteView(this.params.viewId);
+            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: `View deleted: ${this.params.viewId}`,
+                returnDisplay: `Deleted view: ${this.params.viewId}`,
+            };
+        }
+        catch (error) {
+            return {
+                llmContent: `Error: ${error}`,
+                returnDisplay: `Error: ${error}`,
+                error: { message: String(error), type: types_1.ToolErrorType.EXECUTION_FAILED },
+            };
+        }
+    }
+}
+class KGDeleteViewTool extends base_tool_1.BaseDeclarativeTool {
+    constructor() {
+        super('kg_delete_view', 'Delete KG View', 'Delete a knowledge graph view', types_1.Kind.Other, {
+            type: 'object',
+            properties: {
+                viewId: { type: 'string', description: 'View ID' },
+            },
+            required: ['viewId'],
+        });
+    }
+    createInvocation(params) {
+        return new KGDeleteViewInvocation(params);
+    }
+}
+exports.KGDeleteViewTool = KGDeleteViewTool;

package/dist/tools/knowledgeGraph/kg-execute-view.d.ts

@@ -0,0 +1,9 @@
+import type { ToolInvocation, ToolResult } from '../types';
+import { BaseDeclarativeTool } from '../base-tool';
+export interface KGExecuteViewParams {
+    viewId: string;
+}
+export declare class KGExecuteViewTool extends BaseDeclarativeTool<KGExecuteViewParams, ToolResult> {
+    constructor();
+    protected createInvocation(params: KGExecuteViewParams): ToolInvocation<KGExecuteViewParams, ToolResult>;
+}

package/dist/tools/knowledgeGraph/kg-execute-view.js

@@ -0,0 +1,52 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KGExecuteViewTool = void 0;
+const types_1 = require("../types");
+const base_tool_1 = require("../base-tool");
+const knowledgeGraph_1 = __importDefault(require("../../modules/knowledgeGraph"));
+class KGExecuteViewInvocation extends base_tool_1.BaseToolInvocation {
+    constructor(params) {
+        super(params);
+    }
+    async execute(_signal) {
+        try {
+            const response = await knowledgeGraph_1.default.executeView(this.params.viewId);
+            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: `View executed: ${JSON.stringify(response.data)}`,
+                returnDisplay: `Executed view: ${this.params.viewId}`,
+            };
+        }
+        catch (error) {
+            return {
+                llmContent: `Error: ${error}`,
+                returnDisplay: `Error: ${error}`,
+                error: { message: String(error), type: types_1.ToolErrorType.EXECUTION_FAILED },
+            };
+        }
+    }
+}
+class KGExecuteViewTool extends base_tool_1.BaseDeclarativeTool {
+    constructor() {
+        super('kg_execute_view', 'Execute KG View', 'Execute a knowledge graph view query', types_1.Kind.Other, {
+            type: 'object',
+            properties: {
+                viewId: { type: 'string', description: 'View ID' },
+            },
+            required: ['viewId'],
+        });
+    }
+    createInvocation(params) {
+        return new KGExecuteViewInvocation(params);
+    }
+}
+exports.KGExecuteViewTool = KGExecuteViewTool;

package/dist/tools/knowledgeGraph/kg-get-instance-template.d.ts

@@ -0,0 +1,9 @@
+import type { ToolInvocation, ToolResult } from '../types';
+import { BaseDeclarativeTool } from '../base-tool';
+export interface KGGetInstanceTemplateParams {
+    templateId: string;
+}
+export declare class KGGetInstanceTemplateTool extends BaseDeclarativeTool<KGGetInstanceTemplateParams, ToolResult> {
+    constructor();
+    protected createInvocation(params: KGGetInstanceTemplateParams): ToolInvocation<KGGetInstanceTemplateParams, ToolResult>;
+}

package/dist/tools/knowledgeGraph/kg-get-instance-template.js

@@ -0,0 +1,52 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KGGetInstanceTemplateTool = void 0;
+const types_1 = require("../types");
+const base_tool_1 = require("../base-tool");
+const knowledgeGraph_1 = __importDefault(require("../../modules/knowledgeGraph"));
+class KGGetInstanceTemplateInvocation extends base_tool_1.BaseToolInvocation {
+    constructor(params) {
+        super(params);
+    }
+    async execute(_signal) {
+        try {
+            const response = await knowledgeGraph_1.default.getInstanceTemplate(this.params.templateId);
+            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: `Instance template retrieved: ${JSON.stringify(response.data)}`,
+                returnDisplay: `Retrieved instance template: ${this.params.templateId}`,
+            };
+        }
+        catch (error) {
+            return {
+                llmContent: `Error: ${error}`,
+                returnDisplay: `Error: ${error}`,
+                error: { message: String(error), type: types_1.ToolErrorType.EXECUTION_FAILED },
+            };
+        }
+    }
+}
+class KGGetInstanceTemplateTool extends base_tool_1.BaseDeclarativeTool {
+    constructor() {
+        super('kg_get_instance_template', 'Get KG Instance Template', 'Get a knowledge graph instance template by ID', types_1.Kind.Other, {
+            type: 'object',
+            properties: {
+                templateId: { type: 'string', description: 'Template ID' },
+            },
+            required: ['templateId'],
+        });
+    }
+    createInvocation(params) {
+        return new KGGetInstanceTemplateInvocation(params);
+    }
+}
+exports.KGGetInstanceTemplateTool = KGGetInstanceTemplateTool;

package/dist/tools/knowledgeGraph/kg-get-instance.d.ts

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

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

@@ -0,0 +1,52 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KGGetInstanceTool = void 0;
+const types_1 = require("../types");
+const base_tool_1 = require("../base-tool");
+const knowledgeGraph_1 = __importDefault(require("../../modules/knowledgeGraph"));
+class KGGetInstanceInvocation extends base_tool_1.BaseToolInvocation {
+    constructor(params) {
+        super(params);
+    }
+    async execute(_signal) {
+        try {
+            const response = await knowledgeGraph_1.default.getInstance(this.params.instanceId);
+            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: `Knowledge graph instance retrieved: ${JSON.stringify(response.data)}`,
+                returnDisplay: `Retrieved KG instance: ${this.params.instanceId}`,
+            };
+        }
+        catch (error) {
+            return {
+                llmContent: `Error: ${error}`,
+                returnDisplay: `Error: ${error}`,
+                error: { message: String(error), type: types_1.ToolErrorType.EXECUTION_FAILED },
+            };
+        }
+    }
+}
+class KGGetInstanceTool extends base_tool_1.BaseDeclarativeTool {
+    constructor() {
+        super('kg_get_instance', 'Get KG Instance', 'Get a knowledge graph instance by ID', types_1.Kind.Other, {
+            type: 'object',
+            properties: {
+                instanceId: { type: 'string', description: 'Instance ID' },
+            },
+            required: ['instanceId'],
+        });
+    }
+    createInvocation(params) {
+        return new KGGetInstanceInvocation(params);
+    }
+}
+exports.KGGetInstanceTool = KGGetInstanceTool;

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

@@ -0,0 +1,10 @@
+import type { ToolInvocation, ToolResult } from '../types';
+import { BaseDeclarativeTool } from '../base-tool';
+export interface KGGetMemoryRecordParams {
+    instanceId: string;
+    recordId: string;
+}
+export declare class KGGetMemoryRecordTool extends BaseDeclarativeTool<KGGetMemoryRecordParams, ToolResult> {
+    constructor();
+    protected createInvocation(params: KGGetMemoryRecordParams): ToolInvocation<KGGetMemoryRecordParams, ToolResult>;
+}

package/dist/tools/knowledgeGraph/kg-get-memory-record.js

@@ -0,0 +1,53 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KGGetMemoryRecordTool = void 0;
+const types_1 = require("../types");
+const base_tool_1 = require("../base-tool");
+const knowledgeGraph_1 = __importDefault(require("../../modules/knowledgeGraph"));
+class KGGetMemoryRecordInvocation extends base_tool_1.BaseToolInvocation {
+    constructor(params) {
+        super(params);
+    }
+    async execute(_signal) {
+        try {
+            const response = await knowledgeGraph_1.default.getMemoryRecord(this.params.instanceId, this.params.recordId);
+            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: `Memory record retrieved: ${JSON.stringify(response.data)}`,
+                returnDisplay: `Retrieved memory record: ${this.params.recordId}`,
+            };
+        }
+        catch (error) {
+            return {
+                llmContent: `Error: ${error}`,
+                returnDisplay: `Error: ${error}`,
+                error: { message: String(error), type: types_1.ToolErrorType.EXECUTION_FAILED },
+            };
+        }
+    }
+}
+class KGGetMemoryRecordTool extends base_tool_1.BaseDeclarativeTool {
+    constructor() {
+        super('kg_get_memory_record', 'Get KG Memory Record', 'Get a memory record by ID', types_1.Kind.Other, {
+            type: 'object',
+            properties: {
+                instanceId: { type: 'string', description: 'Instance ID' },
+                recordId: { type: 'string', description: 'Record ID' },
+            },
+            required: ['instanceId', 'recordId'],
+        });
+    }
+    createInvocation(params) {
+        return new KGGetMemoryRecordInvocation(params);
+    }
+}
+exports.KGGetMemoryRecordTool = KGGetMemoryRecordTool;

package/dist/tools/knowledgeGraph/kg-get-view-template.d.ts

@@ -0,0 +1,9 @@
+import type { ToolInvocation, ToolResult } from '../types';
+import { BaseDeclarativeTool } from '../base-tool';
+export interface KGGetViewTemplateParams {
+    templateId: string;
+}
+export declare class KGGetViewTemplateTool extends BaseDeclarativeTool<KGGetViewTemplateParams, ToolResult> {
+    constructor();
+    protected createInvocation(params: KGGetViewTemplateParams): ToolInvocation<KGGetViewTemplateParams, ToolResult>;
+}

package/dist/tools/knowledgeGraph/kg-get-view-template.js

@@ -0,0 +1,52 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KGGetViewTemplateTool = void 0;
+const types_1 = require("../types");
+const base_tool_1 = require("../base-tool");
+const knowledgeGraph_1 = __importDefault(require("../../modules/knowledgeGraph"));
+class KGGetViewTemplateInvocation extends base_tool_1.BaseToolInvocation {
+    constructor(params) {
+        super(params);
+    }
+    async execute(_signal) {
+        try {
+            const response = await knowledgeGraph_1.default.getViewTemplate(this.params.templateId);
+            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: `View template retrieved: ${JSON.stringify(response.data)}`,
+                returnDisplay: `Retrieved view template: ${this.params.templateId}`,
+            };
+        }
+        catch (error) {
+            return {
+                llmContent: `Error: ${error}`,
+                returnDisplay: `Error: ${error}`,
+                error: { message: String(error), type: types_1.ToolErrorType.EXECUTION_FAILED },
+            };
+        }
+    }
+}
+class KGGetViewTemplateTool extends base_tool_1.BaseDeclarativeTool {
+    constructor() {
+        super('kg_get_view_template', 'Get KG View Template', 'Get a view template by ID', types_1.Kind.Other, {
+            type: 'object',
+            properties: {
+                templateId: { type: 'string', description: 'Template ID' },
+            },
+            required: ['templateId'],
+        });
+    }
+    createInvocation(params) {
+        return new KGGetViewTemplateInvocation(params);
+    }
+}
+exports.KGGetViewTemplateTool = KGGetViewTemplateTool;

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

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

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

@@ -0,0 +1,57 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KGListEdgesTool = void 0;
+const types_1 = require("../types");
+const base_tool_1 = require("../base-tool");
+const knowledgeGraph_1 = __importDefault(require("../../modules/knowledgeGraph"));
+class KGListEdgesInvocation extends base_tool_1.BaseToolInvocation {
+    constructor(params) {
+        super(params);
+    }
+    async execute(_signal) {
+        try {
+            const response = await knowledgeGraph_1.default.listEdges(this.params.instanceId, this.params.filters);
+            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: `Found ${edges.length} edges: ${JSON.stringify(edges)}`,
+                returnDisplay: `Listed ${edges.length} edges`,
+            };
+        }
+        catch (error) {
+            return {
+                llmContent: `Error: ${error}`,
+                returnDisplay: `Error: ${error}`,
+                error: { message: String(error), type: types_1.ToolErrorType.EXECUTION_FAILED },
+            };
+        }
+    }
+}
+class KGListEdgesTool extends base_tool_1.BaseDeclarativeTool {
+    constructor() {
+        super('kg_list_edges', 'List KG Edges', 'List edges in a knowledge graph instance', types_1.Kind.Other, {
+            type: 'object',
+            properties: {
+                instanceId: { type: 'string', description: 'Instance ID' },
+                filters: {
+                    type: 'object',
+                    description: 'Optional filters',
+                },
+            },
+            required: ['instanceId'],
+        });
+    }
+    createInvocation(params) {
+        return new KGListEdgesInvocation(params);
+    }
+}
+exports.KGListEdgesTool = KGListEdgesTool;

package/dist/tools/knowledgeGraph/kg-list-instance-templates.d.ts

@@ -0,0 +1,8 @@
+import type { ToolInvocation, ToolResult } from '../types';
+import { BaseDeclarativeTool } from '../base-tool';
+export interface KGListInstanceTemplatesParams {
+}
+export declare class KGListInstanceTemplatesTool extends BaseDeclarativeTool<KGListInstanceTemplatesParams, ToolResult> {
+    constructor();
+    protected createInvocation(params: KGListInstanceTemplatesParams): ToolInvocation<KGListInstanceTemplatesParams, ToolResult>;
+}

package/dist/tools/knowledgeGraph/kg-list-instance-templates.js

@@ -0,0 +1,51 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KGListInstanceTemplatesTool = void 0;
+const types_1 = require("../types");
+const base_tool_1 = require("../base-tool");
+const knowledgeGraph_1 = __importDefault(require("../../modules/knowledgeGraph"));
+class KGListInstanceTemplatesInvocation extends base_tool_1.BaseToolInvocation {
+    constructor(params) {
+        super(params);
+    }
+    async execute(_signal) {
+        try {
+            const response = await knowledgeGraph_1.default.listInstanceTemplates();
+            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 templates = response.data || [];
+            return {
+                llmContent: `Found ${templates.length} instance templates: ${JSON.stringify(templates)}`,
+                returnDisplay: `Listed ${templates.length} instance templates`,
+            };
+        }
+        catch (error) {
+            return {
+                llmContent: `Error: ${error}`,
+                returnDisplay: `Error: ${error}`,
+                error: { message: String(error), type: types_1.ToolErrorType.EXECUTION_FAILED },
+            };
+        }
+    }
+}
+class KGListInstanceTemplatesTool extends base_tool_1.BaseDeclarativeTool {
+    constructor() {
+        super('kg_list_instance_templates', 'List KG Instance Templates', 'List all knowledge graph instance templates', types_1.Kind.Other, {
+            type: 'object',
+            properties: {},
+            required: [],
+        });
+    }
+    createInvocation(params) {
+        return new KGListInstanceTemplatesInvocation(params);
+    }
+}
+exports.KGListInstanceTemplatesTool = KGListInstanceTemplatesTool;

package/dist/tools/knowledgeGraph/kg-list-instances.d.ts

@@ -0,0 +1,9 @@
+import type { ToolInvocation, ToolResult } from '../types';
+import { BaseDeclarativeTool } from '../base-tool';
+export interface KGListInstancesParams {
+    templateId?: string;
+}
+export declare class KGListInstancesTool extends BaseDeclarativeTool<KGListInstancesParams, ToolResult> {
+    constructor();
+    protected createInvocation(params: KGListInstancesParams): ToolInvocation<KGListInstancesParams, ToolResult>;
+}

package/dist/tools/knowledgeGraph/kg-list-instances.js

@@ -0,0 +1,53 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KGListInstancesTool = void 0;
+const types_1 = require("../types");
+const base_tool_1 = require("../base-tool");
+const knowledgeGraph_1 = __importDefault(require("../../modules/knowledgeGraph"));
+class KGListInstancesInvocation extends base_tool_1.BaseToolInvocation {
+    constructor(params) {
+        super(params);
+    }
+    async execute(_signal) {
+        try {
+            const response = await knowledgeGraph_1.default.listInstances(this.params.templateId);
+            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 instances = response.data || [];
+            return {
+                llmContent: `Found ${instances.length} KG instances: ${JSON.stringify(instances)}`,
+                returnDisplay: `Listed ${instances.length} KG instances`,
+            };
+        }
+        catch (error) {
+            return {
+                llmContent: `Error: ${error}`,
+                returnDisplay: `Error: ${error}`,
+                error: { message: String(error), type: types_1.ToolErrorType.EXECUTION_FAILED },
+            };
+        }
+    }
+}
+class KGListInstancesTool extends base_tool_1.BaseDeclarativeTool {
+    constructor() {
+        super('kg_list_instances', 'List KG Instances', 'List knowledge graph instances, optionally filtered by template', types_1.Kind.Other, {
+            type: 'object',
+            properties: {
+                templateId: { type: 'string', description: 'Optional template ID filter' },
+            },
+            required: [],
+        });
+    }
+    createInvocation(params) {
+        return new KGListInstancesInvocation(params);
+    }
+}
+exports.KGListInstancesTool = KGListInstancesTool;

package/dist/tools/knowledgeGraph/kg-list-memory-records.d.ts

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