@codebolt/codeboltjs 5.0.1 → 5.0.3

package/dist/tools/calendar/calendar-delete-event.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Calendar Delete Event Tool - Deletes a calendar event
+ * Wraps the SDK's cbcalendar.deleteEvent() method
+ */
+import type { ToolInvocation, ToolResult } from '../types';
+import { BaseDeclarativeTool } from '../base-tool';
+/**
+ * Parameters for the CalendarDeleteEvent tool
+ */
+export interface CalendarDeleteEventToolParams {
+    /**
+     * ID of the event to delete (required)
+     */
+    eventId: string;
+}
+/**
+ * Implementation of the CalendarDeleteEvent tool
+ */
+export declare class CalendarDeleteEventTool extends BaseDeclarativeTool<CalendarDeleteEventToolParams, ToolResult> {
+    static readonly Name: string;
+    constructor();
+    protected validateToolParamValues(params: CalendarDeleteEventToolParams): string | null;
+    protected createInvocation(params: CalendarDeleteEventToolParams): ToolInvocation<CalendarDeleteEventToolParams, ToolResult>;
+}

package/dist/tools/calendar/calendar-delete-event.js

@@ -0,0 +1,80 @@
+"use strict";
+/**
+ * Calendar Delete Event Tool - Deletes a calendar event
+ * Wraps the SDK's cbcalendar.deleteEvent() method
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CalendarDeleteEventTool = void 0;
+const types_1 = require("../types");
+const base_tool_1 = require("../base-tool");
+const calendar_1 = __importDefault(require("../../modules/calendar"));
+class CalendarDeleteEventToolInvocation extends base_tool_1.BaseToolInvocation {
+    constructor(params) {
+        super(params);
+    }
+    async execute() {
+        var _a;
+        try {
+            const response = await calendar_1.default.deleteEvent({
+                eventId: this.params.eventId,
+            });
+            if (!response.success) {
+                const errorMsg = ((_a = response.error) === null || _a === void 0 ? void 0 : _a.message) || response.message || 'Unknown error';
+                return {
+                    llmContent: `Error deleting calendar event: ${errorMsg}`,
+                    returnDisplay: `Error deleting calendar event: ${errorMsg}`,
+                    error: {
+                        message: errorMsg,
+                        type: types_1.ToolErrorType.EXECUTION_FAILED,
+                    },
+                };
+            }
+            return {
+                llmContent: `Successfully deleted calendar event with ID: ${this.params.eventId}`,
+                returnDisplay: `Deleted calendar event (ID: ${this.params.eventId})`,
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+            return {
+                llmContent: `Error deleting calendar event: ${errorMessage}`,
+                returnDisplay: `Error deleting calendar event: ${errorMessage}`,
+                error: {
+                    message: errorMessage,
+                    type: types_1.ToolErrorType.EXECUTION_FAILED,
+                },
+            };
+        }
+    }
+}
+/**
+ * Implementation of the CalendarDeleteEvent tool
+ */
+class CalendarDeleteEventTool extends base_tool_1.BaseDeclarativeTool {
+    constructor() {
+        super(CalendarDeleteEventTool.Name, 'CalendarDeleteEvent', `Deletes a calendar event by its ID. This action is permanent and cannot be undone.`, types_1.Kind.Delete, {
+            properties: {
+                eventId: {
+                    description: 'ID of the event to delete (required)',
+                    type: 'string',
+                },
+            },
+            required: ['eventId'],
+            type: 'object',
+        });
+    }
+    validateToolParamValues(params) {
+        if (!params.eventId || params.eventId.trim() === '') {
+            return "The 'eventId' parameter must be non-empty.";
+        }
+        return null;
+    }
+    createInvocation(params) {
+        return new CalendarDeleteEventToolInvocation(params);
+    }
+}
+exports.CalendarDeleteEventTool = CalendarDeleteEventTool;
+CalendarDeleteEventTool.Name = 'calendar_delete_event';

package/dist/tools/calendar/calendar-get-event.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Calendar Get Event Tool - Retrieves a single calendar event by ID
+ * Wraps the SDK's cbcalendar.getEvent() method
+ */
+import type { ToolInvocation, ToolResult } from '../types';
+import { BaseDeclarativeTool } from '../base-tool';
+/**
+ * Parameters for the CalendarGetEvent tool
+ */
+export interface CalendarGetEventToolParams {
+    /**
+     * ID of the event to retrieve (required)
+     */
+    eventId: string;
+}
+/**
+ * Implementation of the CalendarGetEvent tool
+ */
+export declare class CalendarGetEventTool extends BaseDeclarativeTool<CalendarGetEventToolParams, ToolResult> {
+    static readonly Name: string;
+    constructor();
+    protected validateToolParamValues(params: CalendarGetEventToolParams): string | null;
+    protected createInvocation(params: CalendarGetEventToolParams): ToolInvocation<CalendarGetEventToolParams, ToolResult>;
+}

package/dist/tools/calendar/calendar-get-event.js

@@ -0,0 +1,91 @@
+"use strict";
+/**
+ * Calendar Get Event Tool - Retrieves a single calendar event by ID
+ * Wraps the SDK's cbcalendar.getEvent() method
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CalendarGetEventTool = void 0;
+const types_1 = require("../types");
+const base_tool_1 = require("../base-tool");
+const calendar_1 = __importDefault(require("../../modules/calendar"));
+class CalendarGetEventToolInvocation extends base_tool_1.BaseToolInvocation {
+    constructor(params) {
+        super(params);
+    }
+    async execute() {
+        var _a, _b;
+        try {
+            const response = await calendar_1.default.getEvent({
+                eventId: this.params.eventId,
+            });
+            if (!response.success) {
+                const errorMsg = ((_a = response.error) === null || _a === void 0 ? void 0 : _a.message) || response.message || 'Unknown error';
+                return {
+                    llmContent: `Error retrieving calendar event: ${errorMsg}`,
+                    returnDisplay: `Error retrieving calendar event: ${errorMsg}`,
+                    error: {
+                        message: errorMsg,
+                        type: types_1.ToolErrorType.EXECUTION_FAILED,
+                    },
+                };
+            }
+            const event = (_b = response.data) === null || _b === void 0 ? void 0 : _b.event;
+            if (!event) {
+                return {
+                    llmContent: `Calendar event not found with ID: ${this.params.eventId}`,
+                    returnDisplay: `Event not found (ID: ${this.params.eventId})`,
+                    error: {
+                        message: 'Event not found',
+                        type: types_1.ToolErrorType.EXECUTION_FAILED,
+                    },
+                };
+            }
+            return {
+                llmContent: `Calendar event details:\n${JSON.stringify(event, null, 2)}`,
+                returnDisplay: `Retrieved calendar event: "${event.title}" (ID: ${event.id})`,
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+            return {
+                llmContent: `Error retrieving calendar event: ${errorMessage}`,
+                returnDisplay: `Error retrieving calendar event: ${errorMessage}`,
+                error: {
+                    message: errorMessage,
+                    type: types_1.ToolErrorType.EXECUTION_FAILED,
+                },
+            };
+        }
+    }
+}
+/**
+ * Implementation of the CalendarGetEvent tool
+ */
+class CalendarGetEventTool extends base_tool_1.BaseDeclarativeTool {
+    constructor() {
+        super(CalendarGetEventTool.Name, 'CalendarGetEvent', `Retrieves a single calendar event by its ID. Returns the full event details including title, description, times, participants, and all other properties.`, types_1.Kind.Read, {
+            properties: {
+                eventId: {
+                    description: 'ID of the event to retrieve (required)',
+                    type: 'string',
+                },
+            },
+            required: ['eventId'],
+            type: 'object',
+        });
+    }
+    validateToolParamValues(params) {
+        if (!params.eventId || params.eventId.trim() === '') {
+            return "The 'eventId' parameter must be non-empty.";
+        }
+        return null;
+    }
+    createInvocation(params) {
+        return new CalendarGetEventToolInvocation(params);
+    }
+}
+exports.CalendarGetEventTool = CalendarGetEventTool;
+CalendarGetEventTool.Name = 'calendar_get_event';

package/dist/tools/calendar/calendar-get-status.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Calendar Get Status Tool - Retrieves the calendar scheduler status
+ * Wraps the SDK's cbcalendar.getStatus() method
+ */
+import type { ToolInvocation, ToolResult } from '../types';
+import { BaseDeclarativeTool } from '../base-tool';
+/**
+ * Parameters for the CalendarGetStatus tool (no parameters required)
+ */
+export interface CalendarGetStatusToolParams {
+}
+/**
+ * Implementation of the CalendarGetStatus tool
+ */
+export declare class CalendarGetStatusTool extends BaseDeclarativeTool<CalendarGetStatusToolParams, ToolResult> {
+    static readonly Name: string;
+    constructor();
+    protected createInvocation(params: CalendarGetStatusToolParams): ToolInvocation<CalendarGetStatusToolParams, ToolResult>;
+}

package/dist/tools/calendar/calendar-get-status.js

@@ -0,0 +1,84 @@
+"use strict";
+/**
+ * Calendar Get Status Tool - Retrieves the calendar scheduler status
+ * Wraps the SDK's cbcalendar.getStatus() method
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CalendarGetStatusTool = void 0;
+const types_1 = require("../types");
+const base_tool_1 = require("../base-tool");
+const calendar_1 = __importDefault(require("../../modules/calendar"));
+class CalendarGetStatusToolInvocation extends base_tool_1.BaseToolInvocation {
+    constructor(params) {
+        super(params);
+    }
+    async execute() {
+        var _a;
+        try {
+            const response = await calendar_1.default.getStatus();
+            if (!response.success) {
+                const errorMsg = ((_a = response.error) === null || _a === void 0 ? void 0 : _a.message) || response.message || 'Unknown error';
+                return {
+                    llmContent: `Error retrieving calendar status: ${errorMsg}`,
+                    returnDisplay: `Error retrieving calendar status: ${errorMsg}`,
+                    error: {
+                        message: errorMsg,
+                        type: types_1.ToolErrorType.EXECUTION_FAILED,
+                    },
+                };
+            }
+            const status = response.data;
+            if (!status) {
+                return {
+                    llmContent: 'Calendar status information is not available.',
+                    returnDisplay: 'Calendar status unavailable',
+                    error: {
+                        message: 'Status information not available',
+                        type: types_1.ToolErrorType.EXECUTION_FAILED,
+                    },
+                };
+            }
+            const statusInfo = {
+                isRunning: status.isRunning,
+                lastCheck: status.lastCheck,
+                nextCheck: status.nextCheck,
+                scheduledEvents: status.scheduledEvents,
+            };
+            return {
+                llmContent: `Calendar scheduler status:\n${JSON.stringify(statusInfo, null, 2)}`,
+                returnDisplay: `Calendar status: ${status.isRunning ? 'Running' : 'Stopped'} | ${status.scheduledEvents} scheduled events`,
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+            return {
+                llmContent: `Error retrieving calendar status: ${errorMessage}`,
+                returnDisplay: `Error retrieving calendar status: ${errorMessage}`,
+                error: {
+                    message: errorMessage,
+                    type: types_1.ToolErrorType.EXECUTION_FAILED,
+                },
+            };
+        }
+    }
+}
+/**
+ * Implementation of the CalendarGetStatus tool
+ */
+class CalendarGetStatusTool extends base_tool_1.BaseDeclarativeTool {
+    constructor() {
+        super(CalendarGetStatusTool.Name, 'CalendarGetStatus', `Retrieves the current status of the calendar scheduler. Returns information about whether the scheduler is running, the last and next check times, and the number of scheduled events.`, types_1.Kind.Read, {
+            properties: {},
+            required: [],
+            type: 'object',
+        });
+    }
+    createInvocation(params) {
+        return new CalendarGetStatusToolInvocation(params);
+    }
+}
+exports.CalendarGetStatusTool = CalendarGetStatusTool;
+CalendarGetStatusTool.Name = 'calendar_get_status';

package/dist/tools/calendar/calendar-get-upcoming.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Calendar Get Upcoming Events Tool - Retrieves upcoming calendar events
+ * Wraps the SDK's cbcalendar.getUpcomingEvents() method
+ */
+import type { ToolInvocation, ToolResult } from '../types';
+import { BaseDeclarativeTool } from '../base-tool';
+/**
+ * Parameters for the CalendarGetUpcoming tool
+ */
+export interface CalendarGetUpcomingToolParams {
+    /**
+     * Number of minutes to look ahead (optional, defaults to 60)
+     */
+    withinMinutes?: number;
+}
+/**
+ * Implementation of the CalendarGetUpcoming tool
+ */
+export declare class CalendarGetUpcomingTool extends BaseDeclarativeTool<CalendarGetUpcomingToolParams, ToolResult> {
+    static readonly Name: string;
+    constructor();
+    protected validateToolParamValues(params: CalendarGetUpcomingToolParams): string | null;
+    protected createInvocation(params: CalendarGetUpcomingToolParams): ToolInvocation<CalendarGetUpcomingToolParams, ToolResult>;
+}

package/dist/tools/calendar/calendar-get-upcoming.js

@@ -0,0 +1,96 @@
+"use strict";
+/**
+ * Calendar Get Upcoming Events Tool - Retrieves upcoming calendar events
+ * Wraps the SDK's cbcalendar.getUpcomingEvents() method
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CalendarGetUpcomingTool = void 0;
+const types_1 = require("../types");
+const base_tool_1 = require("../base-tool");
+const calendar_1 = __importDefault(require("../../modules/calendar"));
+class CalendarGetUpcomingToolInvocation extends base_tool_1.BaseToolInvocation {
+    constructor(params) {
+        super(params);
+    }
+    async execute() {
+        var _a, _b, _c;
+        try {
+            const response = await calendar_1.default.getUpcomingEvents({
+                withinMinutes: this.params.withinMinutes,
+            });
+            if (!response.success) {
+                const errorMsg = ((_a = response.error) === null || _a === void 0 ? void 0 : _a.message) || response.message || 'Unknown error';
+                return {
+                    llmContent: `Error retrieving upcoming calendar events: ${errorMsg}`,
+                    returnDisplay: `Error retrieving upcoming events: ${errorMsg}`,
+                    error: {
+                        message: errorMsg,
+                        type: types_1.ToolErrorType.EXECUTION_FAILED,
+                    },
+                };
+            }
+            const events = ((_b = response.data) === null || _b === void 0 ? void 0 : _b.events) || [];
+            const count = ((_c = response.data) === null || _c === void 0 ? void 0 : _c.count) || events.length;
+            const withinMinutes = this.params.withinMinutes || 60;
+            if (events.length === 0) {
+                return {
+                    llmContent: `No upcoming calendar events within the next ${withinMinutes} minutes.`,
+                    returnDisplay: `No upcoming events within ${withinMinutes} minutes`,
+                };
+            }
+            const eventSummaries = events.map((event) => ({
+                id: event.id,
+                title: event.title,
+                eventType: event.eventType,
+                startTime: event.startTime,
+                endTime: event.endTime,
+            }));
+            return {
+                llmContent: `Found ${count} upcoming calendar event(s) within the next ${withinMinutes} minutes:\n\n${JSON.stringify(eventSummaries, null, 2)}\n\nFull event details:\n${JSON.stringify(events, null, 2)}`,
+                returnDisplay: `Found ${count} upcoming event(s) within ${withinMinutes} minutes`,
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+            return {
+                llmContent: `Error retrieving upcoming calendar events: ${errorMessage}`,
+                returnDisplay: `Error retrieving upcoming events: ${errorMessage}`,
+                error: {
+                    message: errorMessage,
+                    type: types_1.ToolErrorType.EXECUTION_FAILED,
+                },
+            };
+        }
+    }
+}
+/**
+ * Implementation of the CalendarGetUpcoming tool
+ */
+class CalendarGetUpcomingTool extends base_tool_1.BaseDeclarativeTool {
+    constructor() {
+        super(CalendarGetUpcomingTool.Name, 'CalendarGetUpcoming', `Retrieves upcoming calendar events within a specified time window. By default, returns events within the next 60 minutes. Use the withinMinutes parameter to adjust the time window.`, types_1.Kind.Read, {
+            properties: {
+                withinMinutes: {
+                    description: 'Number of minutes to look ahead for upcoming events (optional, defaults to 60)',
+                    type: 'number',
+                },
+            },
+            required: [],
+            type: 'object',
+        });
+    }
+    validateToolParamValues(params) {
+        if (params.withinMinutes !== undefined && params.withinMinutes <= 0) {
+            return "The 'withinMinutes' parameter must be a positive number.";
+        }
+        return null;
+    }
+    createInvocation(params) {
+        return new CalendarGetUpcomingToolInvocation(params);
+    }
+}
+exports.CalendarGetUpcomingTool = CalendarGetUpcomingTool;
+CalendarGetUpcomingTool.Name = 'calendar_get_upcoming';

package/dist/tools/calendar/calendar-list-events.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Calendar List Events Tool - Lists calendar events with optional filters
+ * Wraps the SDK's cbcalendar.listEvents() method
+ */
+import type { ToolInvocation, ToolResult } from '../types';
+import { BaseDeclarativeTool } from '../base-tool';
+import { type CalendarEventType } from '../../modules/calendar';
+/**
+ * Parameters for the CalendarListEvents tool
+ */
+export interface CalendarListEventsToolParams {
+    /**
+     * Start date for filtering events (ISO 8601 format)
+     */
+    startDate?: string;
+    /**
+     * End date for filtering events (ISO 8601 format)
+     */
+    endDate?: string;
+    /**
+     * Filter by event types
+     */
+    eventTypes?: CalendarEventType[];
+    /**
+     * Filter by creator ID
+     */
+    creatorId?: string;
+    /**
+     * Filter by participant ID
+     */
+    participantId?: string;
+    /**
+     * Filter by swarm ID
+     */
+    swarmId?: string;
+    /**
+     * Include recurrences in the results
+     */
+    includeRecurrences?: boolean;
+    /**
+     * Filter by tags
+     */
+    tags?: string[];
+    /**
+     * Search query string
+     */
+    search?: string;
+    /**
+     * Filter by completion status
+     */
+    completed?: boolean;
+    /**
+     * Include completed events in results
+     */
+    includeCompleted?: boolean;
+    /**
+     * Only return triggered events (start time has passed)
+     */
+    onlyTriggered?: boolean;
+}
+/**
+ * Implementation of the CalendarListEvents tool
+ */
+export declare class CalendarListEventsTool extends BaseDeclarativeTool<CalendarListEventsToolParams, ToolResult> {
+    static readonly Name: string;
+    constructor();
+    protected createInvocation(params: CalendarListEventsToolParams): ToolInvocation<CalendarListEventsToolParams, ToolResult>;
+}

package/dist/tools/calendar/calendar-list-events.js

@@ -0,0 +1,151 @@
+"use strict";
+/**
+ * Calendar List Events Tool - Lists calendar events with optional filters
+ * Wraps the SDK's cbcalendar.listEvents() method
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CalendarListEventsTool = void 0;
+const types_1 = require("../types");
+const base_tool_1 = require("../base-tool");
+const calendar_1 = __importDefault(require("../../modules/calendar"));
+class CalendarListEventsToolInvocation extends base_tool_1.BaseToolInvocation {
+    constructor(params) {
+        super(params);
+    }
+    async execute() {
+        var _a, _b, _c;
+        try {
+            const listParams = {
+                startDate: this.params.startDate,
+                endDate: this.params.endDate,
+                eventTypes: this.params.eventTypes,
+                creatorId: this.params.creatorId,
+                participantId: this.params.participantId,
+                swarmId: this.params.swarmId,
+                includeRecurrences: this.params.includeRecurrences,
+                tags: this.params.tags,
+                search: this.params.search,
+                completed: this.params.completed,
+                includeCompleted: this.params.includeCompleted,
+                onlyTriggered: this.params.onlyTriggered,
+            };
+            const response = await calendar_1.default.listEvents(listParams);
+            if (!response.success) {
+                const errorMsg = ((_a = response.error) === null || _a === void 0 ? void 0 : _a.message) || response.message || 'Unknown error';
+                return {
+                    llmContent: `Error listing calendar events: ${errorMsg}`,
+                    returnDisplay: `Error listing calendar events: ${errorMsg}`,
+                    error: {
+                        message: errorMsg,
+                        type: types_1.ToolErrorType.EXECUTION_FAILED,
+                    },
+                };
+            }
+            const events = ((_b = response.data) === null || _b === void 0 ? void 0 : _b.events) || [];
+            const count = ((_c = response.data) === null || _c === void 0 ? void 0 : _c.count) || events.length;
+            if (events.length === 0) {
+                return {
+                    llmContent: 'No calendar events found matching the specified filters.',
+                    returnDisplay: 'No events found',
+                };
+            }
+            const eventSummaries = events.map((event) => ({
+                id: event.id,
+                title: event.title,
+                eventType: event.eventType,
+                startTime: event.startTime,
+                endTime: event.endTime,
+                completed: event.completed,
+            }));
+            return {
+                llmContent: `Found ${count} calendar event(s):\n\n${JSON.stringify(eventSummaries, null, 2)}\n\nFull event details:\n${JSON.stringify(events, null, 2)}`,
+                returnDisplay: `Found ${count} calendar event(s)`,
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+            return {
+                llmContent: `Error listing calendar events: ${errorMessage}`,
+                returnDisplay: `Error listing calendar events: ${errorMessage}`,
+                error: {
+                    message: errorMessage,
+                    type: types_1.ToolErrorType.EXECUTION_FAILED,
+                },
+            };
+        }
+    }
+}
+/**
+ * Implementation of the CalendarListEvents tool
+ */
+class CalendarListEventsTool extends base_tool_1.BaseDeclarativeTool {
+    constructor() {
+        super(CalendarListEventsTool.Name, 'CalendarListEvents', `Lists calendar events with optional filters. Can filter by date range, event types, creator, participant, swarm, tags, search query, and completion status.`, types_1.Kind.Read, {
+            properties: {
+                startDate: {
+                    description: 'Start date for filtering events in ISO 8601 format',
+                    type: 'string',
+                },
+                endDate: {
+                    description: 'End date for filtering events in ISO 8601 format',
+                    type: 'string',
+                },
+                eventTypes: {
+                    description: 'Filter by event types',
+                    type: 'array',
+                    items: {
+                        type: 'string',
+                        enum: ['generic', 'meeting', 'reminder', 'deadline', 'check', 'milestone'],
+                    },
+                },
+                creatorId: {
+                    description: 'Filter by creator ID',
+                    type: 'string',
+                },
+                participantId: {
+                    description: 'Filter by participant ID',
+                    type: 'string',
+                },
+                swarmId: {
+                    description: 'Filter by swarm ID',
+                    type: 'string',
+                },
+                includeRecurrences: {
+                    description: 'Include recurrences in the results',
+                    type: 'boolean',
+                },
+                tags: {
+                    description: 'Filter by tags',
+                    type: 'array',
+                    items: { type: 'string' },
+                },
+                search: {
+                    description: 'Search query string to filter events',
+                    type: 'string',
+                },
+                completed: {
+                    description: 'Filter by completion status (true for completed, false for incomplete)',
+                    type: 'boolean',
+                },
+                includeCompleted: {
+                    description: 'Include completed events in results (default behavior may exclude them)',
+                    type: 'boolean',
+                },
+                onlyTriggered: {
+                    description: 'Only return triggered events (events whose start time has passed)',
+                    type: 'boolean',
+                },
+            },
+            required: [],
+            type: 'object',
+        });
+    }
+    createInvocation(params) {
+        return new CalendarListEventsToolInvocation(params);
+    }
+}
+exports.CalendarListEventsTool = CalendarListEventsTool;
+CalendarListEventsTool.Name = 'calendar_list_events';