@codebolt/codeboltjs 5.0.2 → 5.0.3

package/dist/tools/orchestrator/orchestrator-update.js

@@ -0,0 +1,111 @@
+"use strict";
+/**
+ * Orchestrator Update Tool - Updates an existing orchestrator
+ * Wraps the SDK's orchestrator.updateOrchestrator() method
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OrchestratorUpdateTool = void 0;
+const types_1 = require("../types");
+const base_tool_1 = require("../base-tool");
+const orchestrator_1 = __importDefault(require("../../modules/orchestrator"));
+class OrchestratorUpdateInvocation extends base_tool_1.BaseToolInvocation {
+    constructor(params) {
+        super(params);
+    }
+    async execute() {
+        var _a;
+        try {
+            const updateData = {};
+            if (this.params.name !== undefined)
+                updateData.name = this.params.name;
+            if (this.params.description !== undefined)
+                updateData.description = this.params.description;
+            if (this.params.agent_id !== undefined)
+                updateData.agentId = this.params.agent_id;
+            if (this.params.default_worker_agent_id !== undefined)
+                updateData.defaultWorkerAgentId = this.params.default_worker_agent_id;
+            if (this.params.metadata !== undefined)
+                updateData.metadata = this.params.metadata;
+            const response = await orchestrator_1.default.updateOrchestrator(this.params.orchestrator_id, updateData);
+            if (response && response.success === false) {
+                const errorMsg = ((_a = response.error) === null || _a === void 0 ? void 0 : _a.message) || 'Failed to update orchestrator';
+                return {
+                    llmContent: `Orchestrator update failed: ${errorMsg}`,
+                    returnDisplay: `Error: ${errorMsg}`,
+                    error: {
+                        message: errorMsg,
+                        type: types_1.ToolErrorType.EXECUTION_FAILED,
+                    },
+                };
+            }
+            let output = `Updated orchestrator: ${this.params.orchestrator_id}`;
+            if (response.data) {
+                output += `\n\nUpdated Orchestrator Details:\n`;
+                output += JSON.stringify(response.data, null, 2);
+            }
+            return {
+                llmContent: output,
+                returnDisplay: `Updated orchestrator: ${this.params.orchestrator_id}`,
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+            return {
+                llmContent: `Error updating orchestrator: ${errorMessage}`,
+                returnDisplay: `Error: ${errorMessage}`,
+                error: {
+                    message: errorMessage,
+                    type: types_1.ToolErrorType.EXECUTION_FAILED,
+                },
+            };
+        }
+    }
+}
+class OrchestratorUpdateTool extends base_tool_1.BaseDeclarativeTool {
+    constructor() {
+        super(OrchestratorUpdateTool.Name, 'OrchestratorUpdate', 'Updates an existing orchestrator.', types_1.Kind.Edit, {
+            properties: {
+                orchestrator_id: {
+                    description: 'The ID of the orchestrator to update.',
+                    type: 'string',
+                },
+                name: {
+                    description: 'New name for the orchestrator.',
+                    type: 'string',
+                },
+                description: {
+                    description: 'New description for the orchestrator.',
+                    type: 'string',
+                },
+                agent_id: {
+                    description: 'New agent ID for the orchestrator.',
+                    type: 'string',
+                },
+                default_worker_agent_id: {
+                    description: 'New default worker agent ID.',
+                    type: 'string',
+                },
+                metadata: {
+                    description: 'Updated metadata for the orchestrator.',
+                    type: 'object',
+                },
+            },
+            required: ['orchestrator_id'],
+            type: 'object',
+        });
+    }
+    validateToolParamValues(params) {
+        if (!params.orchestrator_id || params.orchestrator_id.trim() === '') {
+            return "'orchestrator_id' is required for orchestrator update";
+        }
+        return null;
+    }
+    createInvocation(params) {
+        return new OrchestratorUpdateInvocation(params);
+    }
+}
+exports.OrchestratorUpdateTool = OrchestratorUpdateTool;
+OrchestratorUpdateTool.Name = 'orchestrator_update';

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

@@ -0,0 +1,21 @@
+/**
+ * Output Parsers Tools
+ *
+ * Tools for parsing various output formats (JSON, XML, CSV, text) and extracting errors/warnings.
+ */
+export { OutputParsersParseJSONTool } from './outputparsers-parse-json';
+export { OutputParsersParseXMLTool } from './outputparsers-parse-xml';
+export { OutputParsersParseCSVTool } from './outputparsers-parse-csv';
+export { OutputParsersParseTextTool } from './outputparsers-parse-text';
+export { OutputParsersParseErrorsTool } from './outputparsers-parse-errors';
+export { OutputParsersParseWarningsTool } from './outputparsers-parse-warnings';
+import { OutputParsersParseJSONTool } from './outputparsers-parse-json';
+import { OutputParsersParseXMLTool } from './outputparsers-parse-xml';
+import { OutputParsersParseCSVTool } from './outputparsers-parse-csv';
+import { OutputParsersParseTextTool } from './outputparsers-parse-text';
+import { OutputParsersParseErrorsTool } from './outputparsers-parse-errors';
+import { OutputParsersParseWarningsTool } from './outputparsers-parse-warnings';
+/**
+ * Array of all output parser tools
+ */
+export declare const outputParsersTools: (OutputParsersParseJSONTool | OutputParsersParseXMLTool | OutputParsersParseCSVTool | OutputParsersParseTextTool | OutputParsersParseErrorsTool | OutputParsersParseWarningsTool)[];

package/dist/tools/outputparsers/index.js

@@ -0,0 +1,37 @@
+"use strict";
+/**
+ * Output Parsers Tools
+ *
+ * Tools for parsing various output formats (JSON, XML, CSV, text) and extracting errors/warnings.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.outputParsersTools = exports.OutputParsersParseWarningsTool = exports.OutputParsersParseErrorsTool = exports.OutputParsersParseTextTool = exports.OutputParsersParseCSVTool = exports.OutputParsersParseXMLTool = exports.OutputParsersParseJSONTool = void 0;
+var outputparsers_parse_json_1 = require("./outputparsers-parse-json");
+Object.defineProperty(exports, "OutputParsersParseJSONTool", { enumerable: true, get: function () { return outputparsers_parse_json_1.OutputParsersParseJSONTool; } });
+var outputparsers_parse_xml_1 = require("./outputparsers-parse-xml");
+Object.defineProperty(exports, "OutputParsersParseXMLTool", { enumerable: true, get: function () { return outputparsers_parse_xml_1.OutputParsersParseXMLTool; } });
+var outputparsers_parse_csv_1 = require("./outputparsers-parse-csv");
+Object.defineProperty(exports, "OutputParsersParseCSVTool", { enumerable: true, get: function () { return outputparsers_parse_csv_1.OutputParsersParseCSVTool; } });
+var outputparsers_parse_text_1 = require("./outputparsers-parse-text");
+Object.defineProperty(exports, "OutputParsersParseTextTool", { enumerable: true, get: function () { return outputparsers_parse_text_1.OutputParsersParseTextTool; } });
+var outputparsers_parse_errors_1 = require("./outputparsers-parse-errors");
+Object.defineProperty(exports, "OutputParsersParseErrorsTool", { enumerable: true, get: function () { return outputparsers_parse_errors_1.OutputParsersParseErrorsTool; } });
+var outputparsers_parse_warnings_1 = require("./outputparsers-parse-warnings");
+Object.defineProperty(exports, "OutputParsersParseWarningsTool", { enumerable: true, get: function () { return outputparsers_parse_warnings_1.OutputParsersParseWarningsTool; } });
+const outputparsers_parse_json_2 = require("./outputparsers-parse-json");
+const outputparsers_parse_xml_2 = require("./outputparsers-parse-xml");
+const outputparsers_parse_csv_2 = require("./outputparsers-parse-csv");
+const outputparsers_parse_text_2 = require("./outputparsers-parse-text");
+const outputparsers_parse_errors_2 = require("./outputparsers-parse-errors");
+const outputparsers_parse_warnings_2 = require("./outputparsers-parse-warnings");
+/**
+ * Array of all output parser tools
+ */
+exports.outputParsersTools = [
+    new outputparsers_parse_json_2.OutputParsersParseJSONTool(),
+    new outputparsers_parse_xml_2.OutputParsersParseXMLTool(),
+    new outputparsers_parse_csv_2.OutputParsersParseCSVTool(),
+    new outputparsers_parse_text_2.OutputParsersParseTextTool(),
+    new outputparsers_parse_errors_2.OutputParsersParseErrorsTool(),
+    new outputparsers_parse_warnings_2.OutputParsersParseWarningsTool(),
+];

package/dist/tools/outputparsers/outputparsers-parse-csv.d.ts

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

package/dist/tools/outputparsers/outputparsers-parse-csv.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.OutputParsersParseCSVTool = void 0;
+const types_1 = require("../types");
+const base_tool_1 = require("../base-tool");
+const outputparsers_1 = __importDefault(require("../../modules/outputparsers"));
+class OutputParsersParseCSVInvocation extends base_tool_1.BaseToolInvocation {
+    constructor(params) {
+        super(params);
+    }
+    async execute(_signal) {
+        var _a, _b, _c, _d;
+        try {
+            const result = outputparsers_1.default.parseCSV(this.params.csvString);
+            if (!result.success) {
+                return {
+                    llmContent: `Error parsing CSV: ${(_a = result.error) === null || _a === void 0 ? void 0 : _a.message}`,
+                    returnDisplay: `Error parsing CSV: ${(_b = result.error) === null || _b === void 0 ? void 0 : _b.message}`,
+                    error: { message: ((_c = result.error) === null || _c === void 0 ? void 0 : _c.message) || 'Unknown error', type: types_1.ToolErrorType.EXECUTION_FAILED },
+                };
+            }
+            return {
+                llmContent: `CSV parsed successfully: ${JSON.stringify(result.parsed)}`,
+                returnDisplay: `Parsed CSV with ${((_d = result.parsed) === null || _d === void 0 ? void 0 : _d.length) || 0} rows`,
+            };
+        }
+        catch (error) {
+            return {
+                llmContent: `Error: ${error}`,
+                returnDisplay: `Error: ${error}`,
+                error: { message: String(error), type: types_1.ToolErrorType.EXECUTION_FAILED },
+            };
+        }
+    }
+}
+class OutputParsersParseCSVTool extends base_tool_1.BaseDeclarativeTool {
+    constructor() {
+        super('outputparsers_parse_csv', 'Parse CSV', 'Parse CSV string and return parsed data', types_1.Kind.Other, {
+            type: 'object',
+            properties: {
+                csvString: { type: 'string', description: 'The CSV string to parse' },
+            },
+            required: ['csvString'],
+        });
+    }
+    createInvocation(params) {
+        return new OutputParsersParseCSVInvocation(params);
+    }
+}
+exports.OutputParsersParseCSVTool = OutputParsersParseCSVTool;

package/dist/tools/outputparsers/outputparsers-parse-errors.d.ts

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

package/dist/tools/outputparsers/outputparsers-parse-errors.js

@@ -0,0 +1,45 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OutputParsersParseErrorsTool = void 0;
+const types_1 = require("../types");
+const base_tool_1 = require("../base-tool");
+const outputparsers_1 = __importDefault(require("../../modules/outputparsers"));
+class OutputParsersParseErrorsInvocation extends base_tool_1.BaseToolInvocation {
+    constructor(params) {
+        super(params);
+    }
+    async execute(_signal) {
+        try {
+            const errors = outputparsers_1.default.parseErrors(this.params.output);
+            return {
+                llmContent: `Found ${errors.length} errors: ${JSON.stringify(errors)}`,
+                returnDisplay: `Found ${errors.length} error messages`,
+            };
+        }
+        catch (error) {
+            return {
+                llmContent: `Error: ${error}`,
+                returnDisplay: `Error: ${error}`,
+                error: { message: String(error), type: types_1.ToolErrorType.EXECUTION_FAILED },
+            };
+        }
+    }
+}
+class OutputParsersParseErrorsTool extends base_tool_1.BaseDeclarativeTool {
+    constructor() {
+        super('outputparsers_parse_errors', 'Parse Errors', 'Parse output and extract error messages', types_1.Kind.Other, {
+            type: 'object',
+            properties: {
+                output: { type: 'string', description: 'The output to parse for error messages' },
+            },
+            required: ['output'],
+        });
+    }
+    createInvocation(params) {
+        return new OutputParsersParseErrorsInvocation(params);
+    }
+}
+exports.OutputParsersParseErrorsTool = OutputParsersParseErrorsTool;

package/dist/tools/outputparsers/outputparsers-parse-json.d.ts

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

package/dist/tools/outputparsers/outputparsers-parse-json.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.OutputParsersParseJSONTool = void 0;
+const types_1 = require("../types");
+const base_tool_1 = require("../base-tool");
+const outputparsers_1 = __importDefault(require("../../modules/outputparsers"));
+class OutputParsersParseJSONInvocation extends base_tool_1.BaseToolInvocation {
+    constructor(params) {
+        super(params);
+    }
+    async execute(_signal) {
+        var _a, _b, _c;
+        try {
+            const result = outputparsers_1.default.parseJSON(this.params.jsonString);
+            if (!result.success) {
+                return {
+                    llmContent: `Error parsing JSON: ${(_a = result.error) === null || _a === void 0 ? void 0 : _a.message}`,
+                    returnDisplay: `Error parsing JSON: ${(_b = result.error) === null || _b === void 0 ? void 0 : _b.message}`,
+                    error: { message: ((_c = result.error) === null || _c === void 0 ? void 0 : _c.message) || 'Unknown error', type: types_1.ToolErrorType.EXECUTION_FAILED },
+                };
+            }
+            return {
+                llmContent: `JSON parsed successfully: ${JSON.stringify(result.parsed)}`,
+                returnDisplay: `Parsed JSON successfully`,
+            };
+        }
+        catch (error) {
+            return {
+                llmContent: `Error: ${error}`,
+                returnDisplay: `Error: ${error}`,
+                error: { message: String(error), type: types_1.ToolErrorType.EXECUTION_FAILED },
+            };
+        }
+    }
+}
+class OutputParsersParseJSONTool extends base_tool_1.BaseDeclarativeTool {
+    constructor() {
+        super('outputparsers_parse_json', 'Parse JSON', 'Parse JSON string and return parsed data', types_1.Kind.Other, {
+            type: 'object',
+            properties: {
+                jsonString: { type: 'string', description: 'The JSON string to parse' },
+            },
+            required: ['jsonString'],
+        });
+    }
+    createInvocation(params) {
+        return new OutputParsersParseJSONInvocation(params);
+    }
+}
+exports.OutputParsersParseJSONTool = OutputParsersParseJSONTool;

package/dist/tools/outputparsers/outputparsers-parse-text.d.ts

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

package/dist/tools/outputparsers/outputparsers-parse-text.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.OutputParsersParseTextTool = void 0;
+const types_1 = require("../types");
+const base_tool_1 = require("../base-tool");
+const outputparsers_1 = __importDefault(require("../../modules/outputparsers"));
+class OutputParsersParseTextInvocation extends base_tool_1.BaseToolInvocation {
+    constructor(params) {
+        super(params);
+    }
+    async execute(_signal) {
+        var _a, _b;
+        try {
+            const result = outputparsers_1.default.parseText(this.params.text);
+            if (!result.success) {
+                return {
+                    llmContent: `Error parsing text`,
+                    returnDisplay: `Error parsing text`,
+                    error: { message: 'Failed to parse text', type: types_1.ToolErrorType.EXECUTION_FAILED },
+                };
+            }
+            return {
+                llmContent: `Text parsed successfully: ${((_a = result.parsed) === null || _a === void 0 ? void 0 : _a.length) || 0} lines`,
+                returnDisplay: `Parsed text into ${((_b = result.parsed) === null || _b === void 0 ? void 0 : _b.length) || 0} lines`,
+            };
+        }
+        catch (error) {
+            return {
+                llmContent: `Error: ${error}`,
+                returnDisplay: `Error: ${error}`,
+                error: { message: String(error), type: types_1.ToolErrorType.EXECUTION_FAILED },
+            };
+        }
+    }
+}
+class OutputParsersParseTextTool extends base_tool_1.BaseDeclarativeTool {
+    constructor() {
+        super('outputparsers_parse_text', 'Parse Text', 'Parse text string and return lines', types_1.Kind.Other, {
+            type: 'object',
+            properties: {
+                text: { type: 'string', description: 'The text to parse' },
+            },
+            required: ['text'],
+        });
+    }
+    createInvocation(params) {
+        return new OutputParsersParseTextInvocation(params);
+    }
+}
+exports.OutputParsersParseTextTool = OutputParsersParseTextTool;

package/dist/tools/outputparsers/outputparsers-parse-warnings.d.ts

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

package/dist/tools/outputparsers/outputparsers-parse-warnings.js

@@ -0,0 +1,45 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OutputParsersParseWarningsTool = void 0;
+const types_1 = require("../types");
+const base_tool_1 = require("../base-tool");
+const outputparsers_1 = __importDefault(require("../../modules/outputparsers"));
+class OutputParsersParseWarningsInvocation extends base_tool_1.BaseToolInvocation {
+    constructor(params) {
+        super(params);
+    }
+    async execute(_signal) {
+        try {
+            const warnings = outputparsers_1.default.parseWarnings(this.params.output);
+            return {
+                llmContent: `Found ${warnings.length} warnings: ${JSON.stringify(warnings)}`,
+                returnDisplay: `Found ${warnings.length} warning messages`,
+            };
+        }
+        catch (error) {
+            return {
+                llmContent: `Error: ${error}`,
+                returnDisplay: `Error: ${error}`,
+                error: { message: String(error), type: types_1.ToolErrorType.EXECUTION_FAILED },
+            };
+        }
+    }
+}
+class OutputParsersParseWarningsTool extends base_tool_1.BaseDeclarativeTool {
+    constructor() {
+        super('outputparsers_parse_warnings', 'Parse Warnings', 'Parse output and extract warning messages', types_1.Kind.Other, {
+            type: 'object',
+            properties: {
+                output: { type: 'string', description: 'The output to parse for warning messages' },
+            },
+            required: ['output'],
+        });
+    }
+    createInvocation(params) {
+        return new OutputParsersParseWarningsInvocation(params);
+    }
+}
+exports.OutputParsersParseWarningsTool = OutputParsersParseWarningsTool;

package/dist/tools/outputparsers/outputparsers-parse-xml.d.ts

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

package/dist/tools/outputparsers/outputparsers-parse-xml.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.OutputParsersParseXMLTool = void 0;
+const types_1 = require("../types");
+const base_tool_1 = require("../base-tool");
+const outputparsers_1 = __importDefault(require("../../modules/outputparsers"));
+class OutputParsersParseXMLInvocation extends base_tool_1.BaseToolInvocation {
+    constructor(params) {
+        super(params);
+    }
+    async execute(_signal) {
+        try {
+            const result = outputparsers_1.default.parseXML(this.params.xmlString);
+            if (!result.success) {
+                return {
+                    llmContent: `Error parsing XML: Invalid XML format`,
+                    returnDisplay: `Error parsing XML: Invalid XML format`,
+                    error: { message: 'Invalid XML format', type: types_1.ToolErrorType.EXECUTION_FAILED },
+                };
+            }
+            return {
+                llmContent: `XML parsed successfully: ${JSON.stringify(result.parsed)}`,
+                returnDisplay: `Parsed XML successfully`,
+            };
+        }
+        catch (error) {
+            return {
+                llmContent: `Error: ${error}`,
+                returnDisplay: `Error: ${error}`,
+                error: { message: String(error), type: types_1.ToolErrorType.EXECUTION_FAILED },
+            };
+        }
+    }
+}
+class OutputParsersParseXMLTool extends base_tool_1.BaseDeclarativeTool {
+    constructor() {
+        super('outputparsers_parse_xml', 'Parse XML', 'Parse XML string and return parsed data', types_1.Kind.Other, {
+            type: 'object',
+            properties: {
+                xmlString: { type: 'string', description: 'The XML string to parse' },
+            },
+            required: ['xmlString'],
+        });
+    }
+    createInvocation(params) {
+        return new OutputParsersParseXMLInvocation(params);
+    }
+}
+exports.OutputParsersParseXMLTool = OutputParsersParseXMLTool;

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

@@ -0,0 +1,25 @@
+/**
+ * Persistent Memory Tools
+ *
+ * Tools for managing persistent memory retrieval configurations for agents.
+ */
+export { PersistentMemoryCreateTool } from './persistent-memory-create';
+export { PersistentMemoryGetTool } from './persistent-memory-get';
+export { PersistentMemoryListTool } from './persistent-memory-list';
+export { PersistentMemoryUpdateTool } from './persistent-memory-update';
+export { PersistentMemoryDeleteTool } from './persistent-memory-delete';
+export { PersistentMemoryExecuteRetrievalTool } from './persistent-memory-execute-retrieval';
+export { PersistentMemoryValidateTool } from './persistent-memory-validate';
+export { PersistentMemoryGetStepSpecsTool } from './persistent-memory-get-step-specs';
+import { PersistentMemoryCreateTool } from './persistent-memory-create';
+import { PersistentMemoryGetTool } from './persistent-memory-get';
+import { PersistentMemoryListTool } from './persistent-memory-list';
+import { PersistentMemoryUpdateTool } from './persistent-memory-update';
+import { PersistentMemoryDeleteTool } from './persistent-memory-delete';
+import { PersistentMemoryExecuteRetrievalTool } from './persistent-memory-execute-retrieval';
+import { PersistentMemoryValidateTool } from './persistent-memory-validate';
+import { PersistentMemoryGetStepSpecsTool } from './persistent-memory-get-step-specs';
+/**
+ * Array of all persistent memory tools
+ */
+export declare const persistentMemoryTools: (PersistentMemoryCreateTool | PersistentMemoryGetTool | PersistentMemoryListTool | PersistentMemoryUpdateTool | PersistentMemoryDeleteTool | PersistentMemoryExecuteRetrievalTool | PersistentMemoryValidateTool | PersistentMemoryGetStepSpecsTool)[];

package/dist/tools/persistentMemory/index.js

@@ -0,0 +1,45 @@
+"use strict";
+/**
+ * Persistent Memory Tools
+ *
+ * Tools for managing persistent memory retrieval configurations for agents.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.persistentMemoryTools = exports.PersistentMemoryGetStepSpecsTool = exports.PersistentMemoryValidateTool = exports.PersistentMemoryExecuteRetrievalTool = exports.PersistentMemoryDeleteTool = exports.PersistentMemoryUpdateTool = exports.PersistentMemoryListTool = exports.PersistentMemoryGetTool = exports.PersistentMemoryCreateTool = void 0;
+var persistent_memory_create_1 = require("./persistent-memory-create");
+Object.defineProperty(exports, "PersistentMemoryCreateTool", { enumerable: true, get: function () { return persistent_memory_create_1.PersistentMemoryCreateTool; } });
+var persistent_memory_get_1 = require("./persistent-memory-get");
+Object.defineProperty(exports, "PersistentMemoryGetTool", { enumerable: true, get: function () { return persistent_memory_get_1.PersistentMemoryGetTool; } });
+var persistent_memory_list_1 = require("./persistent-memory-list");
+Object.defineProperty(exports, "PersistentMemoryListTool", { enumerable: true, get: function () { return persistent_memory_list_1.PersistentMemoryListTool; } });
+var persistent_memory_update_1 = require("./persistent-memory-update");
+Object.defineProperty(exports, "PersistentMemoryUpdateTool", { enumerable: true, get: function () { return persistent_memory_update_1.PersistentMemoryUpdateTool; } });
+var persistent_memory_delete_1 = require("./persistent-memory-delete");
+Object.defineProperty(exports, "PersistentMemoryDeleteTool", { enumerable: true, get: function () { return persistent_memory_delete_1.PersistentMemoryDeleteTool; } });
+var persistent_memory_execute_retrieval_1 = require("./persistent-memory-execute-retrieval");
+Object.defineProperty(exports, "PersistentMemoryExecuteRetrievalTool", { enumerable: true, get: function () { return persistent_memory_execute_retrieval_1.PersistentMemoryExecuteRetrievalTool; } });
+var persistent_memory_validate_1 = require("./persistent-memory-validate");
+Object.defineProperty(exports, "PersistentMemoryValidateTool", { enumerable: true, get: function () { return persistent_memory_validate_1.PersistentMemoryValidateTool; } });
+var persistent_memory_get_step_specs_1 = require("./persistent-memory-get-step-specs");
+Object.defineProperty(exports, "PersistentMemoryGetStepSpecsTool", { enumerable: true, get: function () { return persistent_memory_get_step_specs_1.PersistentMemoryGetStepSpecsTool; } });
+const persistent_memory_create_2 = require("./persistent-memory-create");
+const persistent_memory_get_2 = require("./persistent-memory-get");
+const persistent_memory_list_2 = require("./persistent-memory-list");
+const persistent_memory_update_2 = require("./persistent-memory-update");
+const persistent_memory_delete_2 = require("./persistent-memory-delete");
+const persistent_memory_execute_retrieval_2 = require("./persistent-memory-execute-retrieval");
+const persistent_memory_validate_2 = require("./persistent-memory-validate");
+const persistent_memory_get_step_specs_2 = require("./persistent-memory-get-step-specs");
+/**
+ * Array of all persistent memory tools
+ */
+exports.persistentMemoryTools = [
+    new persistent_memory_create_2.PersistentMemoryCreateTool(),
+    new persistent_memory_get_2.PersistentMemoryGetTool(),
+    new persistent_memory_list_2.PersistentMemoryListTool(),
+    new persistent_memory_update_2.PersistentMemoryUpdateTool(),
+    new persistent_memory_delete_2.PersistentMemoryDeleteTool(),
+    new persistent_memory_execute_retrieval_2.PersistentMemoryExecuteRetrievalTool(),
+    new persistent_memory_validate_2.PersistentMemoryValidateTool(),
+    new persistent_memory_get_step_specs_2.PersistentMemoryGetStepSpecsTool(),
+];

package/dist/tools/persistentMemory/persistent-memory-create.d.ts

@@ -0,0 +1,10 @@
+import type { ToolInvocation, ToolResult } from '../types';
+import { BaseDeclarativeTool } from '../base-tool';
+import type { CreatePersistentMemoryParams } from '../../types/persistentMemory';
+export interface PersistentMemoryCreateParams {
+    config: CreatePersistentMemoryParams;
+}
+export declare class PersistentMemoryCreateTool extends BaseDeclarativeTool<PersistentMemoryCreateParams, ToolResult> {
+    constructor();
+    protected createInvocation(params: PersistentMemoryCreateParams): ToolInvocation<PersistentMemoryCreateParams, ToolResult>;
+}