@dexto/tools-scheduler 1.6.0

package/dist/tool-provider.cjs

@@ -0,0 +1,239 @@
+"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 tool_provider_exports = {};
+__export(tool_provider_exports, {
+  createSchedulerTools: () => createSchedulerTools,
+  ensureSchedulerManagerForAgent: () => ensureSchedulerManagerForAgent,
+  getSchedulerManager: () => getSchedulerManager,
+  schedulerToolsFactory: () => schedulerToolsFactory
+});
+module.exports = __toCommonJS(tool_provider_exports);
+var import_core = require("@dexto/core");
+var import_schemas = require("./schemas.js");
+var import_manager = require("./manager.js");
+var import_errors = require("./errors.js");
+var import_create_schedule = require("./tools/create-schedule.js");
+var import_list_schedules = require("./tools/list-schedules.js");
+var import_get_schedule = require("./tools/get-schedule.js");
+var import_update_schedule = require("./tools/update-schedule.js");
+var import_delete_schedule = require("./tools/delete-schedule.js");
+var import_trigger_schedule = require("./tools/trigger-schedule.js");
+var import_get_history = require("./tools/get-history.js");
+const schedulerManagerRegistry = /* @__PURE__ */ new Map();
+const schedulerConfigRegistry = /* @__PURE__ */ new Map();
+const schedulerManagerInitPromises = /* @__PURE__ */ new Map();
+let defaultSchedulerConfig;
+function getSchedulerManager(agentId) {
+  return schedulerManagerRegistry.get(agentId);
+}
+async function ensureSchedulerManagerForAgent(agent, config, loggerOverride) {
+  if (!agent) {
+    return null;
+  }
+  const agentId = agent.config?.agentId ?? "default";
+  const existing = schedulerManagerRegistry.get(agentId);
+  if (existing) {
+    return existing;
+  }
+  const inflight = schedulerManagerInitPromises.get(agentId);
+  if (inflight) {
+    return inflight;
+  }
+  const agentConfig = schedulerConfigRegistry.get(agentId);
+  const resolvedConfig = config ?? agentConfig ?? defaultSchedulerConfig;
+  if (!resolvedConfig) {
+    return null;
+  }
+  if (!config && !agentConfig && defaultSchedulerConfig) {
+    const logger = loggerOverride ?? agent.logger;
+    logger.debug("Using default scheduler config", { agentId });
+  }
+  const initPromise = (async () => {
+    const storageManager = agent.services?.storageManager;
+    if (!storageManager) {
+      throw import_errors.SchedulerError.missingStorage();
+    }
+    const logger = loggerOverride ?? agent.logger;
+    const manager = new import_manager.SchedulerManager(storageManager, resolvedConfig, logger);
+    const waitForAgentStart = async () => {
+      if (!agent || typeof agent.isStarted !== "function") {
+        return true;
+      }
+      if (agent.isStarted()) {
+        return true;
+      }
+      const timeoutMs = 15e3;
+      const startAt = Date.now();
+      while (!agent.isStarted()) {
+        if (typeof agent.isStopped === "function" && agent.isStopped()) {
+          return false;
+        }
+        if (Date.now() - startAt > timeoutMs) {
+          logger.warn("Scheduler start delayed: agent did not finish starting in time.");
+          return false;
+        }
+        await new Promise((resolve) => setTimeout(resolve, 50));
+      }
+      return true;
+    };
+    const withWorkspaceContext = async (workspacePath, handler) => {
+      if (!agent || typeof agent.getWorkspace !== "function") {
+        return await handler();
+      }
+      const previous = await agent.getWorkspace();
+      const needsChange = workspacePath ? previous?.path !== workspacePath : Boolean(previous);
+      if (needsChange) {
+        if (workspacePath) {
+          await agent.setWorkspace({ path: workspacePath });
+        } else {
+          await agent.clearWorkspace();
+        }
+      }
+      try {
+        return await handler();
+      } finally {
+        if (needsChange) {
+          try {
+            if (!previous) {
+              await agent.clearWorkspace();
+            } else {
+              await agent.setWorkspace({
+                path: previous.path,
+                ...previous.name ? { name: previous.name } : {}
+              });
+            }
+          } catch (restoreError) {
+            logger.error("Failed to restore workspace after scheduled execution", {
+              error: restoreError instanceof Error ? restoreError.message : String(restoreError)
+            });
+          }
+        }
+      }
+    };
+    manager.setExecutor(async ({ prompt, sessionId, schedule }) => {
+      const ready2 = await waitForAgentStart();
+      if (!ready2) {
+        throw import_errors.SchedulerError.executionFailed(
+          schedule.id,
+          "Agent is not started. Scheduled execution skipped."
+        );
+      }
+      agent.emit("run:invoke", {
+        sessionId,
+        content: [{ type: "text", text: prompt }],
+        source: "scheduler",
+        metadata: {
+          trigger: "cron",
+          scheduleId: schedule.id,
+          scheduleName: schedule.name
+        }
+      });
+      const workspacePath = schedule.workspacePath;
+      const response = await withWorkspaceContext(
+        workspacePath,
+        () => agent.generate(prompt, sessionId)
+      );
+      return response.content;
+    });
+    await manager.init();
+    const ready = await waitForAgentStart();
+    if (ready) {
+      try {
+        await manager.start();
+        logger.info("Scheduler started successfully");
+      } catch (error) {
+        await manager.stop().catch(() => void 0);
+        throw error;
+      }
+    } else {
+      logger.warn("Scheduler start skipped because agent is not ready.");
+    }
+    schedulerManagerRegistry.set(agentId, manager);
+    schedulerConfigRegistry.set(agentId, resolvedConfig);
+    agent.services?.toolManager?.registerCleanup(async () => {
+      await manager.stop();
+      schedulerManagerRegistry.delete(agentId);
+      schedulerConfigRegistry.delete(agentId);
+    });
+    return manager;
+  })();
+  schedulerManagerInitPromises.set(agentId, initPromise);
+  try {
+    return await initPromise;
+  } finally {
+    schedulerManagerInitPromises.delete(agentId);
+  }
+}
+function createSchedulerTools(manager) {
+  return [
+    (0, import_create_schedule.createCreateScheduleTool)(async (_context) => manager),
+    (0, import_list_schedules.createListSchedulesTool)(async (_context) => manager),
+    (0, import_get_schedule.createGetScheduleTool)(async (_context) => manager),
+    (0, import_update_schedule.createUpdateScheduleTool)(async (_context) => manager),
+    (0, import_delete_schedule.createDeleteScheduleTool)(async (_context) => manager),
+    (0, import_trigger_schedule.createTriggerScheduleTool)(async (_context) => manager),
+    (0, import_get_history.createGetScheduleHistoryTool)(async (_context) => manager)
+  ];
+}
+const schedulerToolsFactory = {
+  configSchema: import_schemas.SchedulerToolsConfigSchema,
+  metadata: {
+    displayName: "Scheduler Tools",
+    description: "Cron-based scheduling and automations",
+    category: "workflow"
+  },
+  create: (config) => {
+    if (!defaultSchedulerConfig) {
+      defaultSchedulerConfig = config;
+    }
+    const getManager = async (context) => {
+      if (context.agent) {
+        const agentId = context.agent.config?.agentId ?? "default";
+        schedulerConfigRegistry.set(agentId, config);
+      }
+      const manager = await ensureSchedulerManagerForAgent(
+        context.agent,
+        config,
+        context.logger
+      );
+      if (!manager) {
+        throw import_core.ToolError.configInvalid(
+          "scheduler-tools requires ToolExecutionContext.agent"
+        );
+      }
+      return manager;
+    };
+    return [
+      (0, import_create_schedule.createCreateScheduleTool)(getManager),
+      (0, import_list_schedules.createListSchedulesTool)(getManager),
+      (0, import_get_schedule.createGetScheduleTool)(getManager),
+      (0, import_update_schedule.createUpdateScheduleTool)(getManager),
+      (0, import_delete_schedule.createDeleteScheduleTool)(getManager),
+      (0, import_trigger_schedule.createTriggerScheduleTool)(getManager),
+      (0, import_get_history.createGetScheduleHistoryTool)(getManager)
+    ];
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createSchedulerTools,
+  ensureSchedulerManagerForAgent,
+  getSchedulerManager,
+  schedulerToolsFactory
+});

package/dist/tool-provider.d.cts

@@ -0,0 +1,34 @@
+import { ToolFactory } from '@dexto/agent-config';
+import { ToolExecutionContext, Logger, Tool } from '@dexto/core';
+import { SchedulerToolsConfig } from './schemas.cjs';
+import { SchedulerManager } from './manager.cjs';
+import 'zod';
+import './types.cjs';
+
+/**
+ * Scheduler Tools Factory
+ *
+ * Provides cron-based scheduling capabilities for proactive agent behavior.
+ * When a scheduled task triggers, it invokes the agent with the task instruction.
+ */
+
+/**
+ * Get a scheduler manager instance by agent ID.
+ * Returns undefined if no scheduler is registered for the agent.
+ */
+declare function getSchedulerManager(agentId: string): SchedulerManager | undefined;
+/**
+ * Ensure a scheduler manager is available for the given agent.
+ * Returns null if scheduler tools are not enabled in this process.
+ */
+declare function ensureSchedulerManagerForAgent(agent: ToolExecutionContext['agent'], config?: SchedulerToolsConfig, loggerOverride?: Logger): Promise<SchedulerManager | null>;
+/**
+ * Create scheduler tools from an existing manager instance.
+ */
+declare function createSchedulerTools(manager: SchedulerManager): Tool[];
+/**
+ * Scheduler tools factory for Dexto agents.
+ */
+declare const schedulerToolsFactory: ToolFactory<SchedulerToolsConfig>;
+
+export { createSchedulerTools, ensureSchedulerManagerForAgent, getSchedulerManager, schedulerToolsFactory };

package/dist/tool-provider.d.ts

@@ -0,0 +1,34 @@
+import { ToolFactory } from '@dexto/agent-config';
+import { ToolExecutionContext, Logger, Tool } from '@dexto/core';
+import { SchedulerToolsConfig } from './schemas.js';
+import { SchedulerManager } from './manager.js';
+import 'zod';
+import './types.js';
+
+/**
+ * Scheduler Tools Factory
+ *
+ * Provides cron-based scheduling capabilities for proactive agent behavior.
+ * When a scheduled task triggers, it invokes the agent with the task instruction.
+ */
+
+/**
+ * Get a scheduler manager instance by agent ID.
+ * Returns undefined if no scheduler is registered for the agent.
+ */
+declare function getSchedulerManager(agentId: string): SchedulerManager | undefined;
+/**
+ * Ensure a scheduler manager is available for the given agent.
+ * Returns null if scheduler tools are not enabled in this process.
+ */
+declare function ensureSchedulerManagerForAgent(agent: ToolExecutionContext['agent'], config?: SchedulerToolsConfig, loggerOverride?: Logger): Promise<SchedulerManager | null>;
+/**
+ * Create scheduler tools from an existing manager instance.
+ */
+declare function createSchedulerTools(manager: SchedulerManager): Tool[];
+/**
+ * Scheduler tools factory for Dexto agents.
+ */
+declare const schedulerToolsFactory: ToolFactory<SchedulerToolsConfig>;
+
+export { createSchedulerTools, ensureSchedulerManagerForAgent, getSchedulerManager, schedulerToolsFactory };

package/dist/tool-provider.js

@@ -0,0 +1,212 @@
+import { ToolError } from "@dexto/core";
+import { SchedulerToolsConfigSchema } from "./schemas.js";
+import { SchedulerManager } from "./manager.js";
+import { SchedulerError } from "./errors.js";
+import { createCreateScheduleTool } from "./tools/create-schedule.js";
+import { createListSchedulesTool } from "./tools/list-schedules.js";
+import { createGetScheduleTool } from "./tools/get-schedule.js";
+import { createUpdateScheduleTool } from "./tools/update-schedule.js";
+import { createDeleteScheduleTool } from "./tools/delete-schedule.js";
+import { createTriggerScheduleTool } from "./tools/trigger-schedule.js";
+import { createGetScheduleHistoryTool } from "./tools/get-history.js";
+const schedulerManagerRegistry = /* @__PURE__ */ new Map();
+const schedulerConfigRegistry = /* @__PURE__ */ new Map();
+const schedulerManagerInitPromises = /* @__PURE__ */ new Map();
+let defaultSchedulerConfig;
+function getSchedulerManager(agentId) {
+  return schedulerManagerRegistry.get(agentId);
+}
+async function ensureSchedulerManagerForAgent(agent, config, loggerOverride) {
+  if (!agent) {
+    return null;
+  }
+  const agentId = agent.config?.agentId ?? "default";
+  const existing = schedulerManagerRegistry.get(agentId);
+  if (existing) {
+    return existing;
+  }
+  const inflight = schedulerManagerInitPromises.get(agentId);
+  if (inflight) {
+    return inflight;
+  }
+  const agentConfig = schedulerConfigRegistry.get(agentId);
+  const resolvedConfig = config ?? agentConfig ?? defaultSchedulerConfig;
+  if (!resolvedConfig) {
+    return null;
+  }
+  if (!config && !agentConfig && defaultSchedulerConfig) {
+    const logger = loggerOverride ?? agent.logger;
+    logger.debug("Using default scheduler config", { agentId });
+  }
+  const initPromise = (async () => {
+    const storageManager = agent.services?.storageManager;
+    if (!storageManager) {
+      throw SchedulerError.missingStorage();
+    }
+    const logger = loggerOverride ?? agent.logger;
+    const manager = new SchedulerManager(storageManager, resolvedConfig, logger);
+    const waitForAgentStart = async () => {
+      if (!agent || typeof agent.isStarted !== "function") {
+        return true;
+      }
+      if (agent.isStarted()) {
+        return true;
+      }
+      const timeoutMs = 15e3;
+      const startAt = Date.now();
+      while (!agent.isStarted()) {
+        if (typeof agent.isStopped === "function" && agent.isStopped()) {
+          return false;
+        }
+        if (Date.now() - startAt > timeoutMs) {
+          logger.warn("Scheduler start delayed: agent did not finish starting in time.");
+          return false;
+        }
+        await new Promise((resolve) => setTimeout(resolve, 50));
+      }
+      return true;
+    };
+    const withWorkspaceContext = async (workspacePath, handler) => {
+      if (!agent || typeof agent.getWorkspace !== "function") {
+        return await handler();
+      }
+      const previous = await agent.getWorkspace();
+      const needsChange = workspacePath ? previous?.path !== workspacePath : Boolean(previous);
+      if (needsChange) {
+        if (workspacePath) {
+          await agent.setWorkspace({ path: workspacePath });
+        } else {
+          await agent.clearWorkspace();
+        }
+      }
+      try {
+        return await handler();
+      } finally {
+        if (needsChange) {
+          try {
+            if (!previous) {
+              await agent.clearWorkspace();
+            } else {
+              await agent.setWorkspace({
+                path: previous.path,
+                ...previous.name ? { name: previous.name } : {}
+              });
+            }
+          } catch (restoreError) {
+            logger.error("Failed to restore workspace after scheduled execution", {
+              error: restoreError instanceof Error ? restoreError.message : String(restoreError)
+            });
+          }
+        }
+      }
+    };
+    manager.setExecutor(async ({ prompt, sessionId, schedule }) => {
+      const ready2 = await waitForAgentStart();
+      if (!ready2) {
+        throw SchedulerError.executionFailed(
+          schedule.id,
+          "Agent is not started. Scheduled execution skipped."
+        );
+      }
+      agent.emit("run:invoke", {
+        sessionId,
+        content: [{ type: "text", text: prompt }],
+        source: "scheduler",
+        metadata: {
+          trigger: "cron",
+          scheduleId: schedule.id,
+          scheduleName: schedule.name
+        }
+      });
+      const workspacePath = schedule.workspacePath;
+      const response = await withWorkspaceContext(
+        workspacePath,
+        () => agent.generate(prompt, sessionId)
+      );
+      return response.content;
+    });
+    await manager.init();
+    const ready = await waitForAgentStart();
+    if (ready) {
+      try {
+        await manager.start();
+        logger.info("Scheduler started successfully");
+      } catch (error) {
+        await manager.stop().catch(() => void 0);
+        throw error;
+      }
+    } else {
+      logger.warn("Scheduler start skipped because agent is not ready.");
+    }
+    schedulerManagerRegistry.set(agentId, manager);
+    schedulerConfigRegistry.set(agentId, resolvedConfig);
+    agent.services?.toolManager?.registerCleanup(async () => {
+      await manager.stop();
+      schedulerManagerRegistry.delete(agentId);
+      schedulerConfigRegistry.delete(agentId);
+    });
+    return manager;
+  })();
+  schedulerManagerInitPromises.set(agentId, initPromise);
+  try {
+    return await initPromise;
+  } finally {
+    schedulerManagerInitPromises.delete(agentId);
+  }
+}
+function createSchedulerTools(manager) {
+  return [
+    createCreateScheduleTool(async (_context) => manager),
+    createListSchedulesTool(async (_context) => manager),
+    createGetScheduleTool(async (_context) => manager),
+    createUpdateScheduleTool(async (_context) => manager),
+    createDeleteScheduleTool(async (_context) => manager),
+    createTriggerScheduleTool(async (_context) => manager),
+    createGetScheduleHistoryTool(async (_context) => manager)
+  ];
+}
+const schedulerToolsFactory = {
+  configSchema: SchedulerToolsConfigSchema,
+  metadata: {
+    displayName: "Scheduler Tools",
+    description: "Cron-based scheduling and automations",
+    category: "workflow"
+  },
+  create: (config) => {
+    if (!defaultSchedulerConfig) {
+      defaultSchedulerConfig = config;
+    }
+    const getManager = async (context) => {
+      if (context.agent) {
+        const agentId = context.agent.config?.agentId ?? "default";
+        schedulerConfigRegistry.set(agentId, config);
+      }
+      const manager = await ensureSchedulerManagerForAgent(
+        context.agent,
+        config,
+        context.logger
+      );
+      if (!manager) {
+        throw ToolError.configInvalid(
+          "scheduler-tools requires ToolExecutionContext.agent"
+        );
+      }
+      return manager;
+    };
+    return [
+      createCreateScheduleTool(getManager),
+      createListSchedulesTool(getManager),
+      createGetScheduleTool(getManager),
+      createUpdateScheduleTool(getManager),
+      createDeleteScheduleTool(getManager),
+      createTriggerScheduleTool(getManager),
+      createGetScheduleHistoryTool(getManager)
+    ];
+  }
+};
+export {
+  createSchedulerTools,
+  ensureSchedulerManagerForAgent,
+  getSchedulerManager,
+  schedulerToolsFactory
+};

package/dist/tool-types.cjs

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 tool_types_exports = {};
+module.exports = __toCommonJS(tool_types_exports);

package/dist/tool-types.d.cts

@@ -0,0 +1,9 @@
+import { ToolExecutionContext } from '@dexto/core';
+import { SchedulerManager } from './manager.cjs';
+import './schemas.cjs';
+import 'zod';
+import './types.cjs';
+
+type SchedulerManagerGetter = (context: ToolExecutionContext) => Promise<SchedulerManager>;
+
+export type { SchedulerManagerGetter };

package/dist/tool-types.d.ts

@@ -0,0 +1,9 @@
+import { ToolExecutionContext } from '@dexto/core';
+import { SchedulerManager } from './manager.js';
+import './schemas.js';
+import 'zod';
+import './types.js';
+
+type SchedulerManagerGetter = (context: ToolExecutionContext) => Promise<SchedulerManager>;
+
+export type { SchedulerManagerGetter };

package/dist/tools/create-schedule.cjs

@@ -0,0 +1,75 @@
+"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 create_schedule_exports = {};
+__export(create_schedule_exports, {
+  createCreateScheduleTool: () => createCreateScheduleTool
+});
+module.exports = __toCommonJS(create_schedule_exports);
+var import_schemas = require("../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: import_schemas.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 };
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createCreateScheduleTool
+});

package/dist/tools/create-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 creating schedules
+ */
+
+declare function createCreateScheduleTool(getManager: SchedulerManagerGetter): Tool;
+
+export { createCreateScheduleTool };

package/dist/tools/create-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 creating schedules
+ */
+
+declare function createCreateScheduleTool(getManager: SchedulerManagerGetter): Tool;
+
+export { createCreateScheduleTool };