@dexto/tools-scheduler 1.6.0

package/dist/executor.cjs

@@ -0,0 +1,161 @@
+"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 executor_exports = {};
+__export(executor_exports, {
+  ScheduleExecutor: () => ScheduleExecutor
+});
+module.exports = __toCommonJS(executor_exports);
+var import_crypto = require("crypto");
+var import_errors = require("./errors.js");
+class ScheduleExecutor {
+  constructor(executionTimeout, logger) {
+    this.executionTimeout = executionTimeout;
+    this.logger = logger;
+  }
+  executorFn = null;
+  /**
+   * Set the executor function (called to run the agent with a prompt)
+   */
+  setExecutor(fn) {
+    this.executorFn = fn;
+  }
+  /**
+   * Resolve the session ID based on the schedule's session mode
+   *
+   * - ephemeral: New unique session each execution
+   * - dedicated: Persistent session per schedule (schedule-{id})
+   * - inherit: Use the captured session from schedule creation
+   * - fixed: Use the explicitly provided sessionId
+   */
+  resolveSessionId(schedule) {
+    switch (schedule.sessionMode) {
+      case "ephemeral":
+        return `schedule-${schedule.id}-${Date.now()}`;
+      case "dedicated":
+        return `schedule-${schedule.id}`;
+      case "inherit":
+      case "fixed":
+        if (!schedule.sessionId) {
+          this.logger.warn(
+            `Schedule ${schedule.id} has sessionMode '${schedule.sessionMode}' but no sessionId. Falling back to ephemeral.`
+          );
+          return `schedule-${schedule.id}-${Date.now()}`;
+        }
+        return schedule.sessionId;
+      default:
+        return `schedule-${schedule.id}-${Date.now()}`;
+    }
+  }
+  /**
+   * Execute a scheduled task
+   */
+  async execute(schedule) {
+    if (!this.executorFn) {
+      throw import_errors.SchedulerError.executionFailed(schedule.id, "Executor not initialized");
+    }
+    const startTime = Date.now();
+    const log = {
+      id: (0, import_crypto.randomUUID)(),
+      scheduleId: schedule.id,
+      triggeredAt: startTime,
+      status: "pending"
+    };
+    const sessionId = this.resolveSessionId(schedule);
+    try {
+      this.logger.info(`Executing schedule: ${schedule.name}`, {
+        scheduleId: schedule.id,
+        executionId: log.id,
+        sessionId,
+        sessionMode: schedule.sessionMode,
+        cronExpression: schedule.cronExpression
+      });
+      const result = await this.executeWithTimeout(schedule, sessionId);
+      const completedAt = Date.now();
+      log.completedAt = completedAt;
+      log.duration = completedAt - startTime;
+      log.status = "success";
+      log.result = result;
+      this.logger.info(`Schedule executed successfully: ${schedule.name}`, {
+        scheduleId: schedule.id,
+        executionId: log.id,
+        sessionId,
+        durationMs: log.duration
+      });
+    } catch (error) {
+      const completedAt = Date.now();
+      log.completedAt = completedAt;
+      log.duration = completedAt - startTime;
+      if (error instanceof Error && error.name === "TimeoutError") {
+        log.status = "timeout";
+        log.error = `Execution timed out after ${this.executionTimeout}ms`;
+      } else {
+        log.status = "failed";
+        log.error = error instanceof Error ? error.message : String(error);
+      }
+      this.logger.error(`Schedule execution failed: ${schedule.name}`, {
+        scheduleId: schedule.id,
+        executionId: log.id,
+        sessionId,
+        error: log.error,
+        durationMs: log.duration
+      });
+    }
+    return log;
+  }
+  /**
+   * Execute task with timeout
+   */
+  async executeWithTimeout(schedule, sessionId) {
+    return new Promise((resolve, reject) => {
+      const timeoutId = setTimeout(() => {
+        const error = new Error("Execution timeout");
+        error.name = "TimeoutError";
+        reject(error);
+      }, this.executionTimeout);
+      const contextualPrompt = this.wrapPromptWithContext(schedule);
+      this.executorFn({ prompt: contextualPrompt, sessionId, schedule }).then((result) => {
+        clearTimeout(timeoutId);
+        resolve(result);
+      }).catch((error) => {
+        clearTimeout(timeoutId);
+        reject(error);
+      });
+    });
+  }
+  /**
+   * Wrap prompt with execution context
+   * Provides context that this is a scheduled automation trigger
+   */
+  wrapPromptWithContext(schedule) {
+    const scheduleInfo = [
+      `<scheduled_automation_trigger>`,
+      `Task: ${schedule.name}`,
+      `Schedule: ${schedule.cronExpression} (${schedule.timezone})`,
+      `Triggered at: ${(/* @__PURE__ */ new Date()).toISOString()}`,
+      `</scheduled_automation_trigger>`,
+      ``,
+      schedule.task.instruction
+    ].join("\n");
+    return scheduleInfo;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ScheduleExecutor
+});

package/dist/executor.d.cts

@@ -0,0 +1,46 @@
+import { Logger } from '@dexto/core';
+import { ScheduleExecutorFn, Schedule, ExecutionLog } from './types.cjs';
+import './schemas.cjs';
+import 'zod';
+
+/**
+ * Schedule executor - handles execution of scheduled tasks
+ */
+
+/**
+ * Executes scheduled tasks by calling the provided executor function
+ */
+declare class ScheduleExecutor {
+    private executionTimeout;
+    private logger;
+    private executorFn;
+    constructor(executionTimeout: number, logger: Logger);
+    /**
+     * Set the executor function (called to run the agent with a prompt)
+     */
+    setExecutor(fn: ScheduleExecutorFn): void;
+    /**
+     * Resolve the session ID based on the schedule's session mode
+     *
+     * - ephemeral: New unique session each execution
+     * - dedicated: Persistent session per schedule (schedule-{id})
+     * - inherit: Use the captured session from schedule creation
+     * - fixed: Use the explicitly provided sessionId
+     */
+    private resolveSessionId;
+    /**
+     * Execute a scheduled task
+     */
+    execute(schedule: Schedule): Promise<ExecutionLog>;
+    /**
+     * Execute task with timeout
+     */
+    private executeWithTimeout;
+    /**
+     * Wrap prompt with execution context
+     * Provides context that this is a scheduled automation trigger
+     */
+    private wrapPromptWithContext;
+}
+
+export { ScheduleExecutor };

package/dist/executor.d.ts

@@ -0,0 +1,46 @@
+import { Logger } from '@dexto/core';
+import { ScheduleExecutorFn, Schedule, ExecutionLog } from './types.js';
+import './schemas.js';
+import 'zod';
+
+/**
+ * Schedule executor - handles execution of scheduled tasks
+ */
+
+/**
+ * Executes scheduled tasks by calling the provided executor function
+ */
+declare class ScheduleExecutor {
+    private executionTimeout;
+    private logger;
+    private executorFn;
+    constructor(executionTimeout: number, logger: Logger);
+    /**
+     * Set the executor function (called to run the agent with a prompt)
+     */
+    setExecutor(fn: ScheduleExecutorFn): void;
+    /**
+     * Resolve the session ID based on the schedule's session mode
+     *
+     * - ephemeral: New unique session each execution
+     * - dedicated: Persistent session per schedule (schedule-{id})
+     * - inherit: Use the captured session from schedule creation
+     * - fixed: Use the explicitly provided sessionId
+     */
+    private resolveSessionId;
+    /**
+     * Execute a scheduled task
+     */
+    execute(schedule: Schedule): Promise<ExecutionLog>;
+    /**
+     * Execute task with timeout
+     */
+    private executeWithTimeout;
+    /**
+     * Wrap prompt with execution context
+     * Provides context that this is a scheduled automation trigger
+     */
+    private wrapPromptWithContext;
+}
+
+export { ScheduleExecutor };

package/dist/executor.js

@@ -0,0 +1,137 @@
+import { randomUUID } from "crypto";
+import { SchedulerError } from "./errors.js";
+class ScheduleExecutor {
+  constructor(executionTimeout, logger) {
+    this.executionTimeout = executionTimeout;
+    this.logger = logger;
+  }
+  executorFn = null;
+  /**
+   * Set the executor function (called to run the agent with a prompt)
+   */
+  setExecutor(fn) {
+    this.executorFn = fn;
+  }
+  /**
+   * Resolve the session ID based on the schedule's session mode
+   *
+   * - ephemeral: New unique session each execution
+   * - dedicated: Persistent session per schedule (schedule-{id})
+   * - inherit: Use the captured session from schedule creation
+   * - fixed: Use the explicitly provided sessionId
+   */
+  resolveSessionId(schedule) {
+    switch (schedule.sessionMode) {
+      case "ephemeral":
+        return `schedule-${schedule.id}-${Date.now()}`;
+      case "dedicated":
+        return `schedule-${schedule.id}`;
+      case "inherit":
+      case "fixed":
+        if (!schedule.sessionId) {
+          this.logger.warn(
+            `Schedule ${schedule.id} has sessionMode '${schedule.sessionMode}' but no sessionId. Falling back to ephemeral.`
+          );
+          return `schedule-${schedule.id}-${Date.now()}`;
+        }
+        return schedule.sessionId;
+      default:
+        return `schedule-${schedule.id}-${Date.now()}`;
+    }
+  }
+  /**
+   * Execute a scheduled task
+   */
+  async execute(schedule) {
+    if (!this.executorFn) {
+      throw SchedulerError.executionFailed(schedule.id, "Executor not initialized");
+    }
+    const startTime = Date.now();
+    const log = {
+      id: randomUUID(),
+      scheduleId: schedule.id,
+      triggeredAt: startTime,
+      status: "pending"
+    };
+    const sessionId = this.resolveSessionId(schedule);
+    try {
+      this.logger.info(`Executing schedule: ${schedule.name}`, {
+        scheduleId: schedule.id,
+        executionId: log.id,
+        sessionId,
+        sessionMode: schedule.sessionMode,
+        cronExpression: schedule.cronExpression
+      });
+      const result = await this.executeWithTimeout(schedule, sessionId);
+      const completedAt = Date.now();
+      log.completedAt = completedAt;
+      log.duration = completedAt - startTime;
+      log.status = "success";
+      log.result = result;
+      this.logger.info(`Schedule executed successfully: ${schedule.name}`, {
+        scheduleId: schedule.id,
+        executionId: log.id,
+        sessionId,
+        durationMs: log.duration
+      });
+    } catch (error) {
+      const completedAt = Date.now();
+      log.completedAt = completedAt;
+      log.duration = completedAt - startTime;
+      if (error instanceof Error && error.name === "TimeoutError") {
+        log.status = "timeout";
+        log.error = `Execution timed out after ${this.executionTimeout}ms`;
+      } else {
+        log.status = "failed";
+        log.error = error instanceof Error ? error.message : String(error);
+      }
+      this.logger.error(`Schedule execution failed: ${schedule.name}`, {
+        scheduleId: schedule.id,
+        executionId: log.id,
+        sessionId,
+        error: log.error,
+        durationMs: log.duration
+      });
+    }
+    return log;
+  }
+  /**
+   * Execute task with timeout
+   */
+  async executeWithTimeout(schedule, sessionId) {
+    return new Promise((resolve, reject) => {
+      const timeoutId = setTimeout(() => {
+        const error = new Error("Execution timeout");
+        error.name = "TimeoutError";
+        reject(error);
+      }, this.executionTimeout);
+      const contextualPrompt = this.wrapPromptWithContext(schedule);
+      this.executorFn({ prompt: contextualPrompt, sessionId, schedule }).then((result) => {
+        clearTimeout(timeoutId);
+        resolve(result);
+      }).catch((error) => {
+        clearTimeout(timeoutId);
+        reject(error);
+      });
+    });
+  }
+  /**
+   * Wrap prompt with execution context
+   * Provides context that this is a scheduled automation trigger
+   */
+  wrapPromptWithContext(schedule) {
+    const scheduleInfo = [
+      `<scheduled_automation_trigger>`,
+      `Task: ${schedule.name}`,
+      `Schedule: ${schedule.cronExpression} (${schedule.timezone})`,
+      `Triggered at: ${(/* @__PURE__ */ new Date()).toISOString()}`,
+      `</scheduled_automation_trigger>`,
+      ``,
+      schedule.task.instruction
+    ].join("\n");
+    return scheduleInfo;
+  }
+}
+export {
+  ScheduleExecutor
+};

package/dist/index.cjs

@@ -0,0 +1,89 @@
+"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 index_exports = {};
+__export(index_exports, {
+  CreateScheduleInputSchema: () => import_schemas.CreateScheduleInputSchema,
+  DeleteScheduleInputSchema: () => import_schemas.DeleteScheduleInputSchema,
+  GetScheduleHistoryInputSchema: () => import_schemas.GetScheduleHistoryInputSchema,
+  GetScheduleInputSchema: () => import_schemas.GetScheduleInputSchema,
+  ListSchedulesInputSchema: () => import_schemas.ListSchedulesInputSchema,
+  ScheduleExecutor: () => import_executor.ScheduleExecutor,
+  ScheduleSessionModeSchema: () => import_schemas.ScheduleSessionModeSchema,
+  ScheduleStorage: () => import_storage.ScheduleStorage,
+  SchedulerError: () => import_errors.SchedulerError,
+  SchedulerErrorCode: () => import_error_codes.SchedulerErrorCode,
+  SchedulerManager: () => import_manager.SchedulerManager,
+  SchedulerToolsConfigSchema: () => import_schemas.SchedulerToolsConfigSchema,
+  TriggerScheduleInputSchema: () => import_schemas.TriggerScheduleInputSchema,
+  UpdateScheduleInputSchema: () => import_schemas.UpdateScheduleInputSchema,
+  createCreateScheduleTool: () => import_create_schedule.createCreateScheduleTool,
+  createDeleteScheduleTool: () => import_delete_schedule.createDeleteScheduleTool,
+  createGetScheduleHistoryTool: () => import_get_history.createGetScheduleHistoryTool,
+  createGetScheduleTool: () => import_get_schedule.createGetScheduleTool,
+  createListSchedulesTool: () => import_list_schedules.createListSchedulesTool,
+  createSchedulerTools: () => import_tool_provider.createSchedulerTools,
+  createTriggerScheduleTool: () => import_trigger_schedule.createTriggerScheduleTool,
+  createUpdateScheduleTool: () => import_update_schedule.createUpdateScheduleTool,
+  ensureSchedulerManagerForAgent: () => import_tool_provider.ensureSchedulerManagerForAgent,
+  getSchedulerManager: () => import_tool_provider.getSchedulerManager,
+  schedulerToolsFactory: () => import_tool_provider.schedulerToolsFactory
+});
+module.exports = __toCommonJS(index_exports);
+var import_tool_provider = require("./tool-provider.js");
+var import_schemas = require("./schemas.js");
+var import_errors = require("./errors.js");
+var import_error_codes = require("./error-codes.js");
+var import_manager = require("./manager.js");
+var import_storage = require("./storage.js");
+var import_executor = require("./executor.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");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CreateScheduleInputSchema,
+  DeleteScheduleInputSchema,
+  GetScheduleHistoryInputSchema,
+  GetScheduleInputSchema,
+  ListSchedulesInputSchema,
+  ScheduleExecutor,
+  ScheduleSessionModeSchema,
+  ScheduleStorage,
+  SchedulerError,
+  SchedulerErrorCode,
+  SchedulerManager,
+  SchedulerToolsConfigSchema,
+  TriggerScheduleInputSchema,
+  UpdateScheduleInputSchema,
+  createCreateScheduleTool,
+  createDeleteScheduleTool,
+  createGetScheduleHistoryTool,
+  createGetScheduleTool,
+  createListSchedulesTool,
+  createSchedulerTools,
+  createTriggerScheduleTool,
+  createUpdateScheduleTool,
+  ensureSchedulerManagerForAgent,
+  getSchedulerManager,
+  schedulerToolsFactory
+});

package/dist/index.d.cts

@@ -0,0 +1,19 @@
+export { createSchedulerTools, ensureSchedulerManagerForAgent, getSchedulerManager, schedulerToolsFactory } from './tool-provider.cjs';
+export { CreateScheduleInput, CreateScheduleInputSchema, DeleteScheduleInput, DeleteScheduleInputSchema, GetScheduleHistoryInput, GetScheduleHistoryInputSchema, GetScheduleInput, GetScheduleInputSchema, ListSchedulesInput, ListSchedulesInputSchema, ScheduleSessionMode, ScheduleSessionModeSchema, SchedulerToolsConfig, SchedulerToolsConfigSchema, TriggerScheduleInput, TriggerScheduleInputSchema, UpdateScheduleInput, UpdateScheduleInputSchema } from './schemas.cjs';
+export { ExecutionLog, Schedule, ScheduleExecutorFn, ScheduleFilters } from './types.cjs';
+export { SchedulerError } from './errors.cjs';
+export { SchedulerErrorCode } from './error-codes.cjs';
+export { SchedulerManager } from './manager.cjs';
+export { ScheduleStorage } from './storage.cjs';
+export { ScheduleExecutor } from './executor.cjs';
+export { SchedulerManagerGetter } from './tool-types.cjs';
+export { createCreateScheduleTool } from './tools/create-schedule.cjs';
+export { createListSchedulesTool } from './tools/list-schedules.cjs';
+export { createGetScheduleTool } from './tools/get-schedule.cjs';
+export { createUpdateScheduleTool } from './tools/update-schedule.cjs';
+export { createDeleteScheduleTool } from './tools/delete-schedule.cjs';
+export { createTriggerScheduleTool } from './tools/trigger-schedule.cjs';
+export { createGetScheduleHistoryTool } from './tools/get-history.cjs';
+import '@dexto/agent-config';
+import '@dexto/core';
+import 'zod';

package/dist/index.d.ts

@@ -0,0 +1,19 @@
+export { createSchedulerTools, ensureSchedulerManagerForAgent, getSchedulerManager, schedulerToolsFactory } from './tool-provider.js';
+export { CreateScheduleInput, CreateScheduleInputSchema, DeleteScheduleInput, DeleteScheduleInputSchema, GetScheduleHistoryInput, GetScheduleHistoryInputSchema, GetScheduleInput, GetScheduleInputSchema, ListSchedulesInput, ListSchedulesInputSchema, ScheduleSessionMode, ScheduleSessionModeSchema, SchedulerToolsConfig, SchedulerToolsConfigSchema, TriggerScheduleInput, TriggerScheduleInputSchema, UpdateScheduleInput, UpdateScheduleInputSchema } from './schemas.js';
+export { ExecutionLog, Schedule, ScheduleExecutorFn, ScheduleFilters } from './types.js';
+export { SchedulerError } from './errors.js';
+export { SchedulerErrorCode } from './error-codes.js';
+export { SchedulerManager } from './manager.js';
+export { ScheduleStorage } from './storage.js';
+export { ScheduleExecutor } from './executor.js';
+export { SchedulerManagerGetter } from './tool-types.js';
+export { createCreateScheduleTool } from './tools/create-schedule.js';
+export { createListSchedulesTool } from './tools/list-schedules.js';
+export { createGetScheduleTool } from './tools/get-schedule.js';
+export { createUpdateScheduleTool } from './tools/update-schedule.js';
+export { createDeleteScheduleTool } from './tools/delete-schedule.js';
+export { createTriggerScheduleTool } from './tools/trigger-schedule.js';
+export { createGetScheduleHistoryTool } from './tools/get-history.js';
+import '@dexto/agent-config';
+import '@dexto/core';
+import 'zod';

package/dist/index.js

@@ -0,0 +1,56 @@
+import {
+  schedulerToolsFactory,
+  getSchedulerManager,
+  ensureSchedulerManagerForAgent,
+  createSchedulerTools
+} from "./tool-provider.js";
+import {
+  SchedulerToolsConfigSchema,
+  ScheduleSessionModeSchema,
+  CreateScheduleInputSchema,
+  UpdateScheduleInputSchema,
+  ListSchedulesInputSchema,
+  GetScheduleInputSchema,
+  DeleteScheduleInputSchema,
+  TriggerScheduleInputSchema,
+  GetScheduleHistoryInputSchema
+} from "./schemas.js";
+import { SchedulerError } from "./errors.js";
+import { SchedulerErrorCode } from "./error-codes.js";
+import { SchedulerManager } from "./manager.js";
+import { ScheduleStorage } from "./storage.js";
+import { ScheduleExecutor } from "./executor.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";
+export {
+  CreateScheduleInputSchema,
+  DeleteScheduleInputSchema,
+  GetScheduleHistoryInputSchema,
+  GetScheduleInputSchema,
+  ListSchedulesInputSchema,
+  ScheduleExecutor,
+  ScheduleSessionModeSchema,
+  ScheduleStorage,
+  SchedulerError,
+  SchedulerErrorCode,
+  SchedulerManager,
+  SchedulerToolsConfigSchema,
+  TriggerScheduleInputSchema,
+  UpdateScheduleInputSchema,
+  createCreateScheduleTool,
+  createDeleteScheduleTool,
+  createGetScheduleHistoryTool,
+  createGetScheduleTool,
+  createListSchedulesTool,
+  createSchedulerTools,
+  createTriggerScheduleTool,
+  createUpdateScheduleTool,
+  ensureSchedulerManagerForAgent,
+  getSchedulerManager,
+  schedulerToolsFactory
+};