@dexto/tools-scheduler 1.6.0

package/dist/tools/create-schedule.js

@@ -0,0 +1,51 @@
+import { CreateScheduleInputSchema } from "../schemas.js";
+function createCreateScheduleTool(getManager) {
+  return {
+    id: "create_schedule",
+    description: `Create a scheduled task that executes automatically at specified times.
+
+Session Modes (sessionMode parameter):
+\u2022 "ephemeral" (default) - Fresh isolated session each run. Use for: daily reports, monitoring, standalone tasks
+\u2022 "dedicated" - Persistent session for this schedule. Use for: tracking progress over time, building context across runs
+\u2022 "inherit" - Continue in THIS conversation. Use for: "remind me in 1 hour", "check back on this later"
+\u2022 "fixed" - Use specific sessionId. Use for: posting to a known thread, cross-session orchestration
+
+Agent Targeting (targetAgentId parameter):
+\u2022 Specifies which agent should execute the scheduled task
+\u2022 Examples: "notes" for notes agent, "filesystem" for file operations, "coding" for code tasks
+\u2022 If not specified, executes in the orchestrator's context
+\u2022 Use this to delegate specialized tasks to the appropriate app agent
+
+Examples:
+- Daily standup reminder: sessionMode="ephemeral", cronExpression="0 9 * * 1-5"
+- Track project daily: sessionMode="dedicated", cronExpression="0 18 * * *"
+- Remind me in 2 hours: sessionMode="inherit", cronExpression="0 14 * * *" (one-time)
+- Notes backup at midnight: targetAgentId="notes", cronExpression="0 0 * * *"
+- Daily code review: targetAgentId="coding", cronExpression="0 17 * * 1-5"`,
+    inputSchema: CreateScheduleInputSchema,
+    execute: async (input, context) => {
+      const typedInput = input;
+      const manager = await getManager(context);
+      const schedule = await manager.createSchedule(typedInput, context.sessionId);
+      const sessionInfo = schedule.sessionMode === "inherit" ? `Session: Inheriting current conversation (${schedule.sessionId})` : schedule.sessionMode === "fixed" ? `Session: Fixed to ${schedule.sessionId}` : schedule.sessionMode === "dedicated" ? `Session: Dedicated thread for this schedule` : `Session: New isolated session each run`;
+      const targetAgent = schedule.task.metadata?.__os_targetAgentId;
+      const targetInfo = targetAgent ? `Target Agent: ${targetAgent}` : `Target Agent: orchestrator (default)`;
+      const message = `Schedule created successfully
+
+ID: ${schedule.id}
+Name: ${schedule.name}
+Cron: ${schedule.cronExpression}
+Timezone: ${schedule.timezone}
+Mode: ${schedule.sessionMode}
+${sessionInfo}
+${targetInfo}
+Next run: ${schedule.nextRunAt ? new Date(schedule.nextRunAt).toISOString() : "calculating..."}
+
+The schedule is now active and will execute automatically.`;
+      return { message, schedule };
+    }
+  };
+}
+export {
+  createCreateScheduleTool
+};

package/dist/tools/delete-schedule.cjs

@@ -0,0 +1,45 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var delete_schedule_exports = {};
+__export(delete_schedule_exports, {
+  createDeleteScheduleTool: () => createDeleteScheduleTool
+});
+module.exports = __toCommonJS(delete_schedule_exports);
+var import_schemas = require("../schemas.js");
+function createDeleteScheduleTool(getManager) {
+  return {
+    id: "delete_schedule",
+    description: "Delete a schedule permanently. This will stop all future executions of the schedule.",
+    inputSchema: import_schemas.DeleteScheduleInputSchema,
+    execute: async (input, context) => {
+      const { scheduleId } = input;
+      const manager = await getManager(context);
+      await manager.deleteSchedule(scheduleId);
+      return {
+        message: `Schedule deleted successfully: ${scheduleId}`,
+        deleted: true,
+        scheduleId
+      };
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createDeleteScheduleTool
+});

package/dist/tools/delete-schedule.d.cts

@@ -0,0 +1,14 @@
+import { Tool } from '@dexto/core';
+import { SchedulerManagerGetter } from '../tool-types.cjs';
+import '../manager.cjs';
+import '../schemas.cjs';
+import 'zod';
+import '../types.cjs';
+
+/**
+ * Tool for deleting schedules
+ */
+
+declare function createDeleteScheduleTool(getManager: SchedulerManagerGetter): Tool;
+
+export { createDeleteScheduleTool };

package/dist/tools/delete-schedule.d.ts

@@ -0,0 +1,14 @@
+import { Tool } from '@dexto/core';
+import { SchedulerManagerGetter } from '../tool-types.js';
+import '../manager.js';
+import '../schemas.js';
+import 'zod';
+import '../types.js';
+
+/**
+ * Tool for deleting schedules
+ */
+
+declare function createDeleteScheduleTool(getManager: SchedulerManagerGetter): Tool;
+
+export { createDeleteScheduleTool };

package/dist/tools/delete-schedule.js

@@ -0,0 +1,21 @@
+import { DeleteScheduleInputSchema } from "../schemas.js";
+function createDeleteScheduleTool(getManager) {
+  return {
+    id: "delete_schedule",
+    description: "Delete a schedule permanently. This will stop all future executions of the schedule.",
+    inputSchema: DeleteScheduleInputSchema,
+    execute: async (input, context) => {
+      const { scheduleId } = input;
+      const manager = await getManager(context);
+      await manager.deleteSchedule(scheduleId);
+      return {
+        message: `Schedule deleted successfully: ${scheduleId}`,
+        deleted: true,
+        scheduleId
+      };
+    }
+  };
+}
+export {
+  createDeleteScheduleTool
+};

package/dist/tools/get-history.cjs

@@ -0,0 +1,63 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var get_history_exports = {};
+__export(get_history_exports, {
+  createGetScheduleHistoryTool: () => createGetScheduleHistoryTool
+});
+module.exports = __toCommonJS(get_history_exports);
+var import_schemas = require("../schemas.js");
+function createGetScheduleHistoryTool(getManager) {
+  return {
+    id: "get_schedule_history",
+    description: "Get the execution history for a schedule, showing past runs and their results.",
+    inputSchema: import_schemas.GetScheduleHistoryInputSchema,
+    execute: async (input, context) => {
+      const { scheduleId, limit = 10 } = input;
+      const manager = await getManager(context);
+      const logs = await manager.getExecutionHistory(scheduleId, limit);
+      if (logs.length === 0) {
+        return {
+          message: `No execution history found for schedule: ${scheduleId}`,
+          history: []
+        };
+      }
+      const historyList = logs.map((log) => {
+        const statusIcon = log.status === "success" ? "[SUCCESS]" : log.status === "failed" ? "[FAILED]" : log.status === "timeout" ? "[TIMEOUT]" : "[PENDING]";
+        return `
+${statusIcon} Execution ID: ${log.id}
+  Status: ${log.status}
+  Triggered: ${new Date(log.triggeredAt).toISOString()}
+  ${log.completedAt ? `Completed: ${new Date(log.completedAt).toISOString()}` : ""}
+  ${log.duration ? `Duration: ${log.duration}ms` : ""}
+  ${log.error ? `Error: ${log.error}` : ""}
+  ${log.result ? `Result: ${log.result.substring(0, 200)}${log.result.length > 200 ? "..." : ""}` : ""}
+---`;
+      }).join("\n");
+      return {
+        message: `Execution history for schedule ${scheduleId} (showing ${logs.length} most recent):
+${historyList}`,
+        history: logs
+      };
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createGetScheduleHistoryTool
+});

package/dist/tools/get-history.d.cts

@@ -0,0 +1,14 @@
+import { Tool } from '@dexto/core';
+import { SchedulerManagerGetter } from '../tool-types.cjs';
+import '../manager.cjs';
+import '../schemas.cjs';
+import 'zod';
+import '../types.cjs';
+
+/**
+ * Tool for getting schedule execution history
+ */
+
+declare function createGetScheduleHistoryTool(getManager: SchedulerManagerGetter): Tool;
+
+export { createGetScheduleHistoryTool };

package/dist/tools/get-history.d.ts

@@ -0,0 +1,14 @@
+import { Tool } from '@dexto/core';
+import { SchedulerManagerGetter } from '../tool-types.js';
+import '../manager.js';
+import '../schemas.js';
+import 'zod';
+import '../types.js';
+
+/**
+ * Tool for getting schedule execution history
+ */
+
+declare function createGetScheduleHistoryTool(getManager: SchedulerManagerGetter): Tool;
+
+export { createGetScheduleHistoryTool };

package/dist/tools/get-history.js

@@ -0,0 +1,39 @@
+import { GetScheduleHistoryInputSchema } from "../schemas.js";
+function createGetScheduleHistoryTool(getManager) {
+  return {
+    id: "get_schedule_history",
+    description: "Get the execution history for a schedule, showing past runs and their results.",
+    inputSchema: GetScheduleHistoryInputSchema,
+    execute: async (input, context) => {
+      const { scheduleId, limit = 10 } = input;
+      const manager = await getManager(context);
+      const logs = await manager.getExecutionHistory(scheduleId, limit);
+      if (logs.length === 0) {
+        return {
+          message: `No execution history found for schedule: ${scheduleId}`,
+          history: []
+        };
+      }
+      const historyList = logs.map((log) => {
+        const statusIcon = log.status === "success" ? "[SUCCESS]" : log.status === "failed" ? "[FAILED]" : log.status === "timeout" ? "[TIMEOUT]" : "[PENDING]";
+        return `
+${statusIcon} Execution ID: ${log.id}
+  Status: ${log.status}
+  Triggered: ${new Date(log.triggeredAt).toISOString()}
+  ${log.completedAt ? `Completed: ${new Date(log.completedAt).toISOString()}` : ""}
+  ${log.duration ? `Duration: ${log.duration}ms` : ""}
+  ${log.error ? `Error: ${log.error}` : ""}
+  ${log.result ? `Result: ${log.result.substring(0, 200)}${log.result.length > 200 ? "..." : ""}` : ""}
+---`;
+      }).join("\n");
+      return {
+        message: `Execution history for schedule ${scheduleId} (showing ${logs.length} most recent):
+${historyList}`,
+        history: logs
+      };
+    }
+  };
+}
+export {
+  createGetScheduleHistoryTool
+};

package/dist/tools/get-schedule.cjs

@@ -0,0 +1,68 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var get_schedule_exports = {};
+__export(get_schedule_exports, {
+  createGetScheduleTool: () => createGetScheduleTool
+});
+module.exports = __toCommonJS(get_schedule_exports);
+var import_schemas = require("../schemas.js");
+function createGetScheduleTool(getManager) {
+  return {
+    id: "get_schedule",
+    description: "Get detailed information about a specific schedule by ID.",
+    inputSchema: import_schemas.GetScheduleInputSchema,
+    execute: async (input, context) => {
+      const { scheduleId } = input;
+      const manager = await getManager(context);
+      const schedule = await manager.getSchedule(scheduleId);
+      if (!schedule) {
+        throw new Error(`Schedule not found: ${scheduleId}`);
+      }
+      const message = `
+Schedule Details:
+
+ID: ${schedule.id}
+Name: ${schedule.name}
+Status: ${schedule.enabled ? "Enabled" : "Disabled"}
+Cron Expression: ${schedule.cronExpression}
+Timezone: ${schedule.timezone}
+
+Task:
+  Instruction: ${schedule.task.instruction}
+  Metadata: ${JSON.stringify(schedule.task.metadata || {}, null, 2)}
+
+Statistics:
+  Total runs: ${schedule.runCount}
+  Successful: ${schedule.successCount}
+  Failed: ${schedule.failureCount}
+  Last run: ${schedule.lastRunAt ? new Date(schedule.lastRunAt).toISOString() : "Never"}
+  Next run: ${schedule.nextRunAt ? new Date(schedule.nextRunAt).toISOString() : "N/A"}
+  ${schedule.lastError ? `Last error: ${schedule.lastError}` : ""}
+
+Created: ${new Date(schedule.createdAt).toISOString()}
+Updated: ${new Date(schedule.updatedAt).toISOString()}
+`;
+      return { message, schedule };
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createGetScheduleTool
+});

package/dist/tools/get-schedule.d.cts

@@ -0,0 +1,14 @@
+import { Tool } from '@dexto/core';
+import { SchedulerManagerGetter } from '../tool-types.cjs';
+import '../manager.cjs';
+import '../schemas.cjs';
+import 'zod';
+import '../types.cjs';
+
+/**
+ * Tool for getting schedule details
+ */
+
+declare function createGetScheduleTool(getManager: SchedulerManagerGetter): Tool;
+
+export { createGetScheduleTool };

package/dist/tools/get-schedule.d.ts

@@ -0,0 +1,14 @@
+import { Tool } from '@dexto/core';
+import { SchedulerManagerGetter } from '../tool-types.js';
+import '../manager.js';
+import '../schemas.js';
+import 'zod';
+import '../types.js';
+
+/**
+ * Tool for getting schedule details
+ */
+
+declare function createGetScheduleTool(getManager: SchedulerManagerGetter): Tool;
+
+export { createGetScheduleTool };

package/dist/tools/get-schedule.js

@@ -0,0 +1,44 @@
+import { GetScheduleInputSchema } from "../schemas.js";
+function createGetScheduleTool(getManager) {
+  return {
+    id: "get_schedule",
+    description: "Get detailed information about a specific schedule by ID.",
+    inputSchema: GetScheduleInputSchema,
+    execute: async (input, context) => {
+      const { scheduleId } = input;
+      const manager = await getManager(context);
+      const schedule = await manager.getSchedule(scheduleId);
+      if (!schedule) {
+        throw new Error(`Schedule not found: ${scheduleId}`);
+      }
+      const message = `
+Schedule Details:
+
+ID: ${schedule.id}
+Name: ${schedule.name}
+Status: ${schedule.enabled ? "Enabled" : "Disabled"}
+Cron Expression: ${schedule.cronExpression}
+Timezone: ${schedule.timezone}
+
+Task:
+  Instruction: ${schedule.task.instruction}
+  Metadata: ${JSON.stringify(schedule.task.metadata || {}, null, 2)}
+
+Statistics:
+  Total runs: ${schedule.runCount}
+  Successful: ${schedule.successCount}
+  Failed: ${schedule.failureCount}
+  Last run: ${schedule.lastRunAt ? new Date(schedule.lastRunAt).toISOString() : "Never"}
+  Next run: ${schedule.nextRunAt ? new Date(schedule.nextRunAt).toISOString() : "N/A"}
+  ${schedule.lastError ? `Last error: ${schedule.lastError}` : ""}
+
+Created: ${new Date(schedule.createdAt).toISOString()}
+Updated: ${new Date(schedule.updatedAt).toISOString()}
+`;
+      return { message, schedule };
+    }
+  };
+}
+export {
+  createGetScheduleTool
+};

package/dist/tools/list-schedules.cjs

@@ -0,0 +1,67 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var list_schedules_exports = {};
+__export(list_schedules_exports, {
+  createListSchedulesTool: () => createListSchedulesTool
+});
+module.exports = __toCommonJS(list_schedules_exports);
+var import_schemas = require("../schemas.js");
+function createListSchedulesTool(getManager) {
+  return {
+    id: "list_schedules",
+    description: "List all scheduled tasks. Optionally filter by enabled status.",
+    inputSchema: import_schemas.ListSchedulesInputSchema,
+    execute: async (input, context) => {
+      const manager = await getManager(context);
+      const { enabled } = input;
+      const schedules = await manager.listSchedules(enabled !== void 0 ? { enabled } : {});
+      if (schedules.length === 0) {
+        return {
+          message: "No schedules found.",
+          schedules: []
+        };
+      }
+      const scheduleList = schedules.map((s) => {
+        const status = s.enabled ? "Enabled" : "Disabled";
+        const nextRun = s.nextRunAt ? new Date(s.nextRunAt).toISOString() : "N/A";
+        const lastRun = s.lastRunAt ? new Date(s.lastRunAt).toISOString() : "Never";
+        return `
+ID: ${s.id}
+Name: ${s.name}
+Status: ${status}
+Cron: ${s.cronExpression}
+Timezone: ${s.timezone}
+Runs: ${s.runCount} (${s.successCount} success, ${s.failureCount} failed)
+Last run: ${lastRun}
+Next run: ${nextRun}
+${s.lastError ? `Last error: ${s.lastError}` : ""}
+---`;
+      }).join("\n");
+      return {
+        message: `Found ${schedules.length} schedule(s):
+${scheduleList}`,
+        schedules
+      };
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createListSchedulesTool
+});

package/dist/tools/list-schedules.d.cts

@@ -0,0 +1,14 @@
+import { Tool } from '@dexto/core';
+import { SchedulerManagerGetter } from '../tool-types.cjs';
+import '../manager.cjs';
+import '../schemas.cjs';
+import 'zod';
+import '../types.cjs';
+
+/**
+ * Tool for listing schedules
+ */
+
+declare function createListSchedulesTool(getManager: SchedulerManagerGetter): Tool;
+
+export { createListSchedulesTool };

package/dist/tools/list-schedules.d.ts

@@ -0,0 +1,14 @@
+import { Tool } from '@dexto/core';
+import { SchedulerManagerGetter } from '../tool-types.js';
+import '../manager.js';
+import '../schemas.js';
+import 'zod';
+import '../types.js';
+
+/**
+ * Tool for listing schedules
+ */
+
+declare function createListSchedulesTool(getManager: SchedulerManagerGetter): Tool;
+
+export { createListSchedulesTool };

package/dist/tools/list-schedules.js

@@ -0,0 +1,43 @@
+import { ListSchedulesInputSchema } from "../schemas.js";
+function createListSchedulesTool(getManager) {
+  return {
+    id: "list_schedules",
+    description: "List all scheduled tasks. Optionally filter by enabled status.",
+    inputSchema: ListSchedulesInputSchema,
+    execute: async (input, context) => {
+      const manager = await getManager(context);
+      const { enabled } = input;
+      const schedules = await manager.listSchedules(enabled !== void 0 ? { enabled } : {});
+      if (schedules.length === 0) {
+        return {
+          message: "No schedules found.",
+          schedules: []
+        };
+      }
+      const scheduleList = schedules.map((s) => {
+        const status = s.enabled ? "Enabled" : "Disabled";
+        const nextRun = s.nextRunAt ? new Date(s.nextRunAt).toISOString() : "N/A";
+        const lastRun = s.lastRunAt ? new Date(s.lastRunAt).toISOString() : "Never";
+        return `
+ID: ${s.id}
+Name: ${s.name}
+Status: ${status}
+Cron: ${s.cronExpression}
+Timezone: ${s.timezone}
+Runs: ${s.runCount} (${s.successCount} success, ${s.failureCount} failed)
+Last run: ${lastRun}
+Next run: ${nextRun}
+${s.lastError ? `Last error: ${s.lastError}` : ""}
+---`;
+      }).join("\n");
+      return {
+        message: `Found ${schedules.length} schedule(s):
+${scheduleList}`,
+        schedules
+      };
+    }
+  };
+}
+export {
+  createListSchedulesTool
+};

package/dist/tools/trigger-schedule.cjs

@@ -0,0 +1,56 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var trigger_schedule_exports = {};
+__export(trigger_schedule_exports, {
+  createTriggerScheduleTool: () => createTriggerScheduleTool
+});
+module.exports = __toCommonJS(trigger_schedule_exports);
+var import_schemas = require("../schemas.js");
+function createTriggerScheduleTool(getManager) {
+  return {
+    id: "trigger_schedule_now",
+    description: "Manually trigger a schedule to execute immediately, outside of its normal schedule.",
+    inputSchema: import_schemas.TriggerScheduleInputSchema,
+    execute: async (input, context) => {
+      const { scheduleId } = input;
+      const manager = await getManager(context);
+      const log = await manager.triggerScheduleNow(scheduleId);
+      const durationLine = log.duration != null ? `Duration: ${log.duration}ms` : "Duration: (unknown)";
+      const errorLine = log.error ?? "Unknown error";
+      const message = log.status === "success" ? `Schedule executed successfully
+
+Execution ID: ${log.id}
+Status: ${log.status}
+${durationLine}
+
+Result:
+${log.result || "(no result)"}` : `Schedule execution failed
+
+Execution ID: ${log.id}
+Status: ${log.status}
+${durationLine}
+Error: ${errorLine}`;
+      return { message, execution: log };
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createTriggerScheduleTool
+});

package/dist/tools/trigger-schedule.d.cts

@@ -0,0 +1,14 @@
+import { Tool } from '@dexto/core';
+import { SchedulerManagerGetter } from '../tool-types.cjs';
+import '../manager.cjs';
+import '../schemas.cjs';
+import 'zod';
+import '../types.cjs';
+
+/**
+ * Tool for manually triggering schedules
+ */
+
+declare function createTriggerScheduleTool(getManager: SchedulerManagerGetter): Tool;
+
+export { createTriggerScheduleTool };

package/dist/tools/trigger-schedule.d.ts

@@ -0,0 +1,14 @@
+import { Tool } from '@dexto/core';
+import { SchedulerManagerGetter } from '../tool-types.js';
+import '../manager.js';
+import '../schemas.js';
+import 'zod';
+import '../types.js';
+
+/**
+ * Tool for manually triggering schedules
+ */
+
+declare function createTriggerScheduleTool(getManager: SchedulerManagerGetter): Tool;
+
+export { createTriggerScheduleTool };