@codebolt/codeboltjs 5.0.2 → 5.0.3

package/dist/tools/context/context-rule-create.js

@@ -0,0 +1,142 @@
+"use strict";
+/**
+ * Context Rule Create Tool - Creates a new context rule engine
+ * Wraps the SDK's contextRuleEngine.create() method
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContextRuleCreateTool = void 0;
+const types_1 = require("../types");
+const base_tool_1 = require("../base-tool");
+const contextRuleEngine_1 = __importDefault(require("../../modules/contextRuleEngine"));
+class ContextRuleCreateToolInvocation extends base_tool_1.BaseToolInvocation {
+    constructor(params) {
+        super(params);
+    }
+    async execute() {
+        var _a, _b;
+        try {
+            const response = await contextRuleEngine_1.default.create({
+                name: this.params.name,
+                description: this.params.description,
+                rules: this.params.rules,
+                enabled: this.params.enabled,
+            });
+            if (!response.success) {
+                const errorMsg = response.error || response.message || 'Unknown error';
+                return {
+                    llmContent: `Error creating context rule: ${errorMsg}`,
+                    returnDisplay: `Error creating context rule: ${errorMsg}`,
+                    error: {
+                        message: errorMsg,
+                        type: types_1.ToolErrorType.EXECUTION_FAILED,
+                    },
+                };
+            }
+            const ruleEngine = (_a = response.data) === null || _a === void 0 ? void 0 : _a.ruleEngine;
+            const llmContent = ruleEngine
+                ? `Successfully created context rule engine:\nID: ${ruleEngine.id}\nName: ${ruleEngine.name}\nDescription: ${ruleEngine.description || 'N/A'}\nEnabled: ${ruleEngine.enabled}\nRules count: ${((_b = ruleEngine.rules) === null || _b === void 0 ? void 0 : _b.length) || 0}`
+                : 'Context rule engine created successfully';
+            return {
+                llmContent,
+                returnDisplay: `Successfully created context rule engine: ${this.params.name}`,
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+            return {
+                llmContent: `Error creating context rule: ${errorMessage}`,
+                returnDisplay: `Error creating context rule: ${errorMessage}`,
+                error: {
+                    message: errorMessage,
+                    type: types_1.ToolErrorType.EXECUTION_FAILED,
+                },
+            };
+        }
+    }
+}
+/**
+ * Implementation of the ContextRuleCreate tool logic
+ */
+class ContextRuleCreateTool extends base_tool_1.BaseDeclarativeTool {
+    constructor() {
+        super(ContextRuleCreateTool.Name, 'ContextRuleCreate', `Creates a new context rule engine for conditional memory inclusion. A rule engine contains rules that determine when certain memories should be included, excluded, or prioritized based on context variables.`, types_1.Kind.Edit, {
+            properties: {
+                name: {
+                    description: 'The name of the context rule engine',
+                    type: 'string',
+                },
+                description: {
+                    description: 'Optional description of what this rule engine does',
+                    type: 'string',
+                },
+                rules: {
+                    description: 'Array of rules to include in the rule engine. Each rule contains conditions and actions.',
+                    type: 'array',
+                    items: {
+                        type: 'object',
+                        properties: {
+                            name: { type: 'string', description: 'Rule name' },
+                            description: { type: 'string', description: 'Rule description' },
+                            conditions: {
+                                type: 'array',
+                                description: 'Conditions that must be met for the rule to trigger',
+                                items: {
+                                    type: 'object',
+                                    properties: {
+                                        variable: { type: 'string' },
+                                        operator: { type: 'string' },
+                                        value: {},
+                                    },
+                                },
+                            },
+                            condition_logic: { type: 'string', enum: ['and', 'or'] },
+                            action: { type: 'string', enum: ['include', 'exclude', 'force_include', 'set_priority'] },
+                            action_config: { type: 'object' },
+                            enabled: { type: 'boolean' },
+                            order: { type: 'number' },
+                        },
+                        required: ['name', 'conditions', 'action'],
+                    },
+                },
+                enabled: {
+                    description: 'Whether the rule engine is enabled (defaults to true)',
+                    type: 'boolean',
+                },
+            },
+            required: ['name', 'rules'],
+            type: 'object',
+        });
+    }
+    validateToolParamValues(params) {
+        if (!params.name || params.name.trim() === '') {
+            return "The 'name' parameter must be non-empty.";
+        }
+        if (!params.rules || !Array.isArray(params.rules)) {
+            return "The 'rules' parameter must be an array.";
+        }
+        if (params.rules.length === 0) {
+            return "The 'rules' parameter must contain at least one rule.";
+        }
+        for (let i = 0; i < params.rules.length; i++) {
+            const rule = params.rules[i];
+            if (!rule.name || rule.name.trim() === '') {
+                return `Rule at index ${i} must have a non-empty 'name'.`;
+            }
+            if (!rule.conditions || !Array.isArray(rule.conditions)) {
+                return `Rule '${rule.name}' must have a 'conditions' array.`;
+            }
+            if (!rule.action) {
+                return `Rule '${rule.name}' must have an 'action'.`;
+            }
+        }
+        return null;
+    }
+    createInvocation(params) {
+        return new ContextRuleCreateToolInvocation(params);
+    }
+}
+exports.ContextRuleCreateTool = ContextRuleCreateTool;
+ContextRuleCreateTool.Name = 'context_rule_create';

package/dist/tools/context/context-rule-delete.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Context Rule Delete Tool - Deletes a context rule engine by ID
+ * Wraps the SDK's contextRuleEngine.delete() method
+ */
+import type { ToolInvocation, ToolResult } from '../types';
+import { BaseDeclarativeTool } from '../base-tool';
+/**
+ * Parameters for the ContextRuleDelete tool
+ */
+export interface ContextRuleDeleteToolParams {
+    /**
+     * The ID of the context rule engine to delete
+     */
+    id: string;
+}
+/**
+ * Implementation of the ContextRuleDelete tool logic
+ */
+export declare class ContextRuleDeleteTool extends BaseDeclarativeTool<ContextRuleDeleteToolParams, ToolResult> {
+    static readonly Name: string;
+    constructor();
+    protected validateToolParamValues(params: ContextRuleDeleteToolParams): string | null;
+    protected createInvocation(params: ContextRuleDeleteToolParams): ToolInvocation<ContextRuleDeleteToolParams, ToolResult>;
+}

package/dist/tools/context/context-rule-delete.js

@@ -0,0 +1,89 @@
+"use strict";
+/**
+ * Context Rule Delete Tool - Deletes a context rule engine by ID
+ * Wraps the SDK's contextRuleEngine.delete() method
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContextRuleDeleteTool = void 0;
+const types_1 = require("../types");
+const base_tool_1 = require("../base-tool");
+const contextRuleEngine_1 = __importDefault(require("../../modules/contextRuleEngine"));
+class ContextRuleDeleteToolInvocation extends base_tool_1.BaseToolInvocation {
+    constructor(params) {
+        super(params);
+    }
+    async execute() {
+        var _a;
+        try {
+            const response = await contextRuleEngine_1.default.delete(this.params.id);
+            if (!response.success) {
+                const errorMsg = response.error || response.message || 'Unknown error';
+                return {
+                    llmContent: `Error deleting context rule: ${errorMsg}`,
+                    returnDisplay: `Error deleting context rule: ${errorMsg}`,
+                    error: {
+                        message: errorMsg,
+                        type: types_1.ToolErrorType.EXECUTION_FAILED,
+                    },
+                };
+            }
+            const deleted = (_a = response.data) === null || _a === void 0 ? void 0 : _a.deleted;
+            if (deleted === false) {
+                return {
+                    llmContent: `Context rule engine with ID '${this.params.id}' could not be deleted or was not found.`,
+                    returnDisplay: `Context rule engine could not be deleted: ${this.params.id}`,
+                    error: {
+                        message: `Context rule engine could not be deleted: ${this.params.id}`,
+                        type: types_1.ToolErrorType.EXECUTION_FAILED,
+                    },
+                };
+            }
+            return {
+                llmContent: `Successfully deleted context rule engine with ID: ${this.params.id}`,
+                returnDisplay: `Successfully deleted context rule engine: ${this.params.id}`,
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+            return {
+                llmContent: `Error deleting context rule: ${errorMessage}`,
+                returnDisplay: `Error deleting context rule: ${errorMessage}`,
+                error: {
+                    message: errorMessage,
+                    type: types_1.ToolErrorType.EXECUTION_FAILED,
+                },
+            };
+        }
+    }
+}
+/**
+ * Implementation of the ContextRuleDelete tool logic
+ */
+class ContextRuleDeleteTool extends base_tool_1.BaseDeclarativeTool {
+    constructor() {
+        super(ContextRuleDeleteTool.Name, 'ContextRuleDelete', `Deletes a context rule engine by its ID. This action is permanent and cannot be undone.`, types_1.Kind.Delete, {
+            properties: {
+                id: {
+                    description: 'The unique identifier of the context rule engine to delete',
+                    type: 'string',
+                },
+            },
+            required: ['id'],
+            type: 'object',
+        });
+    }
+    validateToolParamValues(params) {
+        if (!params.id || params.id.trim() === '') {
+            return "The 'id' parameter must be a non-empty string.";
+        }
+        return null;
+    }
+    createInvocation(params) {
+        return new ContextRuleDeleteToolInvocation(params);
+    }
+}
+exports.ContextRuleDeleteTool = ContextRuleDeleteTool;
+ContextRuleDeleteTool.Name = 'context_rule_delete';

package/dist/tools/context/context-rule-evaluate.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Context Rule Evaluate Tool - Evaluates context rules against provided variables
+ * Wraps the SDK's contextRuleEngine.evaluate() method
+ */
+import type { ToolInvocation, ToolResult } from '../types';
+import { BaseDeclarativeTool } from '../base-tool';
+/**
+ * Parameters for the ContextRuleEvaluate tool
+ */
+export interface ContextRuleEvaluateToolParams {
+    /**
+     * Scope variables to evaluate rules against
+     */
+    scope_variables: Record<string, any>;
+    /**
+     * Additional variables to include in evaluation
+     */
+    additional_variables?: Record<string, any>;
+    /**
+     * Optional input string for context
+     */
+    input?: string;
+    /**
+     * Optional list of specific rule engine IDs to evaluate
+     */
+    rule_engine_ids?: string[];
+}
+/**
+ * Implementation of the ContextRuleEvaluate tool logic
+ */
+export declare class ContextRuleEvaluateTool extends BaseDeclarativeTool<ContextRuleEvaluateToolParams, ToolResult> {
+    static readonly Name: string;
+    constructor();
+    protected validateToolParamValues(params: ContextRuleEvaluateToolParams): string | null;
+    protected createInvocation(params: ContextRuleEvaluateToolParams): ToolInvocation<ContextRuleEvaluateToolParams, ToolResult>;
+}

package/dist/tools/context/context-rule-evaluate.js

@@ -0,0 +1,123 @@
+"use strict";
+/**
+ * Context Rule Evaluate Tool - Evaluates context rules against provided variables
+ * Wraps the SDK's contextRuleEngine.evaluate() method
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContextRuleEvaluateTool = void 0;
+const types_1 = require("../types");
+const base_tool_1 = require("../base-tool");
+const contextRuleEngine_1 = __importDefault(require("../../modules/contextRuleEngine"));
+class ContextRuleEvaluateToolInvocation extends base_tool_1.BaseToolInvocation {
+    constructor(params) {
+        super(params);
+    }
+    async execute() {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+        try {
+            const response = await contextRuleEngine_1.default.evaluate({
+                scope_variables: this.params.scope_variables,
+                additional_variables: this.params.additional_variables,
+                input: this.params.input,
+                rule_engine_ids: this.params.rule_engine_ids,
+            });
+            if (!response.success) {
+                const errorMsg = response.error || response.message || 'Unknown error';
+                return {
+                    llmContent: `Error evaluating context rules: ${errorMsg}`,
+                    returnDisplay: `Error evaluating context rules: ${errorMsg}`,
+                    error: {
+                        message: errorMsg,
+                        type: types_1.ToolErrorType.EXECUTION_FAILED,
+                    },
+                };
+            }
+            const data = response.data;
+            if (!data) {
+                return {
+                    llmContent: 'Context rules evaluated successfully (no data returned).',
+                    returnDisplay: 'Context rules evaluated successfully.',
+                };
+            }
+            const llmContent = `Context rules evaluation results:
+- Matched rules: ${((_a = data.matched_rules) === null || _a === void 0 ? void 0 : _a.length) || 0}${((_b = data.matched_rules) === null || _b === void 0 ? void 0 : _b.length) ? '\n  ' + data.matched_rules.join(', ') : ''}
+- Included memories: ${((_c = data.included_memories) === null || _c === void 0 ? void 0 : _c.length) || 0}${((_d = data.included_memories) === null || _d === void 0 ? void 0 : _d.length) ? '\n  ' + data.included_memories.join(', ') : ''}
+- Excluded memories: ${((_e = data.excluded_memories) === null || _e === void 0 ? void 0 : _e.length) || 0}${((_f = data.excluded_memories) === null || _f === void 0 ? void 0 : _f.length) ? '\n  ' + data.excluded_memories.join(', ') : ''}
+- Forced memories: ${((_g = data.forced_memories) === null || _g === void 0 ? void 0 : _g.length) || 0}${((_h = data.forced_memories) === null || _h === void 0 ? void 0 : _h.length) ? '\n  ' + data.forced_memories.join(', ') : ''}`;
+            return {
+                llmContent,
+                returnDisplay: `Evaluated context rules: ${((_j = data.matched_rules) === null || _j === void 0 ? void 0 : _j.length) || 0} rules matched`,
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+            return {
+                llmContent: `Error evaluating context rules: ${errorMessage}`,
+                returnDisplay: `Error evaluating context rules: ${errorMessage}`,
+                error: {
+                    message: errorMessage,
+                    type: types_1.ToolErrorType.EXECUTION_FAILED,
+                },
+            };
+        }
+    }
+}
+/**
+ * Implementation of the ContextRuleEvaluate tool logic
+ */
+class ContextRuleEvaluateTool extends base_tool_1.BaseDeclarativeTool {
+    constructor() {
+        super(ContextRuleEvaluateTool.Name, 'ContextRuleEvaluate', `Evaluates context rules against provided variables. Returns which rules matched and which memories should be included, excluded, or forced based on the evaluation.`, types_1.Kind.Execute, {
+            properties: {
+                scope_variables: {
+                    description: 'Scope variables to evaluate rules against (key-value pairs)',
+                    type: 'object',
+                    additionalProperties: true,
+                },
+                additional_variables: {
+                    description: 'Optional additional variables to include in evaluation',
+                    type: 'object',
+                    additionalProperties: true,
+                },
+                input: {
+                    description: 'Optional input string for context',
+                    type: 'string',
+                },
+                rule_engine_ids: {
+                    description: 'Optional list of specific rule engine IDs to evaluate. If not provided, all enabled rule engines are evaluated.',
+                    type: 'array',
+                    items: { type: 'string' },
+                },
+            },
+            required: ['scope_variables'],
+            type: 'object',
+        });
+    }
+    validateToolParamValues(params) {
+        if (!params.scope_variables || typeof params.scope_variables !== 'object') {
+            return "The 'scope_variables' parameter must be an object.";
+        }
+        if (params.additional_variables !== undefined && typeof params.additional_variables !== 'object') {
+            return "The 'additional_variables' parameter must be an object if provided.";
+        }
+        if (params.rule_engine_ids !== undefined) {
+            if (!Array.isArray(params.rule_engine_ids)) {
+                return "The 'rule_engine_ids' parameter must be an array if provided.";
+            }
+            for (const id of params.rule_engine_ids) {
+                if (typeof id !== 'string' || id.trim() === '') {
+                    return "Each rule engine ID must be a non-empty string.";
+                }
+            }
+        }
+        return null;
+    }
+    createInvocation(params) {
+        return new ContextRuleEvaluateToolInvocation(params);
+    }
+}
+exports.ContextRuleEvaluateTool = ContextRuleEvaluateTool;
+ContextRuleEvaluateTool.Name = 'context_rule_evaluate';

package/dist/tools/context/context-rule-get.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Context Rule Get Tool - Gets a context rule engine by ID
+ * Wraps the SDK's contextRuleEngine.get() method
+ */
+import type { ToolInvocation, ToolResult } from '../types';
+import { BaseDeclarativeTool } from '../base-tool';
+/**
+ * Parameters for the ContextRuleGet tool
+ */
+export interface ContextRuleGetToolParams {
+    /**
+     * The ID of the context rule engine to retrieve
+     */
+    id: string;
+}
+/**
+ * Implementation of the ContextRuleGet tool logic
+ */
+export declare class ContextRuleGetTool extends BaseDeclarativeTool<ContextRuleGetToolParams, ToolResult> {
+    static readonly Name: string;
+    constructor();
+    protected validateToolParamValues(params: ContextRuleGetToolParams): string | null;
+    protected createInvocation(params: ContextRuleGetToolParams): ToolInvocation<ContextRuleGetToolParams, ToolResult>;
+}

package/dist/tools/context/context-rule-get.js

@@ -0,0 +1,108 @@
+"use strict";
+/**
+ * Context Rule Get Tool - Gets a context rule engine by ID
+ * Wraps the SDK's contextRuleEngine.get() method
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContextRuleGetTool = void 0;
+const types_1 = require("../types");
+const base_tool_1 = require("../base-tool");
+const contextRuleEngine_1 = __importDefault(require("../../modules/contextRuleEngine"));
+class ContextRuleGetToolInvocation extends base_tool_1.BaseToolInvocation {
+    constructor(params) {
+        super(params);
+    }
+    async execute() {
+        var _a, _b, _c;
+        try {
+            const response = await contextRuleEngine_1.default.get(this.params.id);
+            if (!response.success) {
+                const errorMsg = response.error || response.message || 'Unknown error';
+                return {
+                    llmContent: `Error getting context rule: ${errorMsg}`,
+                    returnDisplay: `Error getting context rule: ${errorMsg}`,
+                    error: {
+                        message: errorMsg,
+                        type: types_1.ToolErrorType.EXECUTION_FAILED,
+                    },
+                };
+            }
+            const ruleEngine = (_a = response.data) === null || _a === void 0 ? void 0 : _a.ruleEngine;
+            if (!ruleEngine) {
+                return {
+                    llmContent: `Context rule engine with ID '${this.params.id}' not found.`,
+                    returnDisplay: `Context rule engine not found: ${this.params.id}`,
+                    error: {
+                        message: `Context rule engine not found: ${this.params.id}`,
+                        type: types_1.ToolErrorType.EXECUTION_FAILED,
+                    },
+                };
+            }
+            const rulesDetails = ((_b = ruleEngine.rules) === null || _b === void 0 ? void 0 : _b.map((rule, index) => {
+                var _a;
+                const conditionsStr = ((_a = rule.conditions) === null || _a === void 0 ? void 0 : _a.map(c => `${c.variable} ${c.operator} ${JSON.stringify(c.value)}`).join(rule.condition_logic === 'or' ? ' OR ' : ' AND ')) || 'No conditions';
+                return `  Rule ${index + 1}: ${rule.name}
+    Description: ${rule.description || 'N/A'}
+    Conditions: ${conditionsStr}
+    Action: ${rule.action}
+    Enabled: ${rule.enabled !== false}`;
+            }).join('\n')) || '  No rules defined';
+            const llmContent = `Context Rule Engine Details:
+ID: ${ruleEngine.id}
+Name: ${ruleEngine.name}
+Description: ${ruleEngine.description || 'N/A'}
+Enabled: ${ruleEngine.enabled}
+Created: ${ruleEngine.createdAt}
+Updated: ${ruleEngine.updatedAt}
+
+Rules (${((_c = ruleEngine.rules) === null || _c === void 0 ? void 0 : _c.length) || 0}):
+${rulesDetails}`;
+            return {
+                llmContent,
+                returnDisplay: `Retrieved context rule engine: ${ruleEngine.name}`,
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+            return {
+                llmContent: `Error getting context rule: ${errorMessage}`,
+                returnDisplay: `Error getting context rule: ${errorMessage}`,
+                error: {
+                    message: errorMessage,
+                    type: types_1.ToolErrorType.EXECUTION_FAILED,
+                },
+            };
+        }
+    }
+}
+/**
+ * Implementation of the ContextRuleGet tool logic
+ */
+class ContextRuleGetTool extends base_tool_1.BaseDeclarativeTool {
+    constructor() {
+        super(ContextRuleGetTool.Name, 'ContextRuleGet', `Gets a context rule engine by its ID. Returns detailed information about the rule engine including all its rules, conditions, and configuration.`, types_1.Kind.Read, {
+            properties: {
+                id: {
+                    description: 'The unique identifier of the context rule engine to retrieve',
+                    type: 'string',
+                },
+            },
+            required: ['id'],
+            type: 'object',
+        });
+    }
+    validateToolParamValues(params) {
+        if (!params.id || params.id.trim() === '') {
+            return "The 'id' parameter must be a non-empty string.";
+        }
+        return null;
+    }
+    createInvocation(params) {
+        return new ContextRuleGetToolInvocation(params);
+    }
+}
+exports.ContextRuleGetTool = ContextRuleGetTool;
+ContextRuleGetTool.Name = 'context_rule_get';

package/dist/tools/context/context-rule-list.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Context Rule List Tool - Lists all context rule engines
+ * Wraps the SDK's contextRuleEngine.list() method
+ */
+import type { ToolInvocation, ToolResult } from '../types';
+import { BaseDeclarativeTool } from '../base-tool';
+/**
+ * Parameters for the ContextRuleList tool
+ */
+export interface ContextRuleListToolParams {
+}
+/**
+ * Implementation of the ContextRuleList tool logic
+ */
+export declare class ContextRuleListTool extends BaseDeclarativeTool<ContextRuleListToolParams, ToolResult> {
+    static readonly Name: string;
+    constructor();
+    protected createInvocation(params: ContextRuleListToolParams): ToolInvocation<ContextRuleListToolParams, ToolResult>;
+}

package/dist/tools/context/context-rule-list.js

@@ -0,0 +1,79 @@
+"use strict";
+/**
+ * Context Rule List Tool - Lists all context rule engines
+ * Wraps the SDK's contextRuleEngine.list() method
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContextRuleListTool = void 0;
+const types_1 = require("../types");
+const base_tool_1 = require("../base-tool");
+const contextRuleEngine_1 = __importDefault(require("../../modules/contextRuleEngine"));
+class ContextRuleListToolInvocation extends base_tool_1.BaseToolInvocation {
+    constructor(params) {
+        super(params);
+    }
+    async execute() {
+        var _a;
+        try {
+            const response = await contextRuleEngine_1.default.list();
+            if (!response.success) {
+                const errorMsg = response.error || response.message || 'Unknown error';
+                return {
+                    llmContent: `Error listing context rules: ${errorMsg}`,
+                    returnDisplay: `Error listing context rules: ${errorMsg}`,
+                    error: {
+                        message: errorMsg,
+                        type: types_1.ToolErrorType.EXECUTION_FAILED,
+                    },
+                };
+            }
+            const ruleEngines = ((_a = response.data) === null || _a === void 0 ? void 0 : _a.ruleEngines) || [];
+            if (ruleEngines.length === 0) {
+                return {
+                    llmContent: 'No context rule engines found.',
+                    returnDisplay: 'No context rule engines found.',
+                };
+            }
+            const engineSummaries = ruleEngines.map((engine) => {
+                var _a;
+                return `- ID: ${engine.id}\n  Name: ${engine.name}\n  Description: ${engine.description || 'N/A'}\n  Enabled: ${engine.enabled}\n  Rules count: ${((_a = engine.rules) === null || _a === void 0 ? void 0 : _a.length) || 0}\n  Created: ${engine.createdAt}\n  Updated: ${engine.updatedAt}`;
+            });
+            const llmContent = `Found ${ruleEngines.length} context rule engine(s):\n\n${engineSummaries.join('\n\n')}`;
+            return {
+                llmContent,
+                returnDisplay: `Found ${ruleEngines.length} context rule engine(s)`,
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+            return {
+                llmContent: `Error listing context rules: ${errorMessage}`,
+                returnDisplay: `Error listing context rules: ${errorMessage}`,
+                error: {
+                    message: errorMessage,
+                    type: types_1.ToolErrorType.EXECUTION_FAILED,
+                },
+            };
+        }
+    }
+}
+/**
+ * Implementation of the ContextRuleList tool logic
+ */
+class ContextRuleListTool extends base_tool_1.BaseDeclarativeTool {
+    constructor() {
+        super(ContextRuleListTool.Name, 'ContextRuleList', `Lists all context rule engines. Returns information about each rule engine including its ID, name, description, enabled status, rules count, and timestamps.`, types_1.Kind.Read, {
+            properties: {},
+            required: [],
+            type: 'object',
+        });
+    }
+    createInvocation(params) {
+        return new ContextRuleListToolInvocation(params);
+    }
+}
+exports.ContextRuleListTool = ContextRuleListTool;
+ContextRuleListTool.Name = 'context_rule_list';

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

@@ -0,0 +1,17 @@
+/**
+ * Context rule engine tools
+ */
+export { ContextRuleCreateTool, type ContextRuleCreateToolParams } from './context-rule-create';
+export { ContextRuleListTool, type ContextRuleListToolParams } from './context-rule-list';
+export { ContextRuleEvaluateTool, type ContextRuleEvaluateToolParams } from './context-rule-evaluate';
+export { ContextRuleGetTool, type ContextRuleGetToolParams } from './context-rule-get';
+export { ContextRuleDeleteTool, type ContextRuleDeleteToolParams } from './context-rule-delete';
+import { ContextRuleCreateTool } from './context-rule-create';
+import { ContextRuleListTool } from './context-rule-list';
+import { ContextRuleEvaluateTool } from './context-rule-evaluate';
+import { ContextRuleGetTool } from './context-rule-get';
+import { ContextRuleDeleteTool } from './context-rule-delete';
+/**
+ * All context rule engine tools
+ */
+export declare const contextTools: (ContextRuleCreateTool | ContextRuleListTool | ContextRuleEvaluateTool | ContextRuleGetTool | ContextRuleDeleteTool)[];