change to duration

Signed-off-by: Ettore Di Giacinto <mudler@localai.io>

Author: mudler

core/action/reminder.go

@@ -12,13 +12,27 @@ import (
 )
 
 const (
+	RecurringReminderActionName = "set_recurring_reminder"
+	OneTimeReminderActionName   = "set_onetime_reminder"
+	ListRemindersName           = "list_reminders"
+	RemoveReminderName          = "remove_reminder"
+
+	// Deprecated: use RecurringReminderActionName or OneTimeReminderActionName
 	ReminderActionName = "set_reminder"
-	ListRemindersName  = "list_reminders"
-	RemoveReminderName = "remove_reminder"
 )
 
-func NewReminder() *ReminderAction {
-	return &ReminderAction{}
+func NewRecurringReminder() *RecurringReminderAction {
+	return &RecurringReminderAction{}
+}
+
+func NewOneTimeReminder() *OneTimeReminderAction {
+	return &OneTimeReminderAction{}
+}
+
+// NewReminder returns a RecurringReminderAction for backward compatibility.
+// Deprecated: use NewRecurringReminder or NewOneTimeReminder.
+func NewReminder() *RecurringReminderAction {
+	return &RecurringReminderAction{}
 }
 
 func NewListReminders() *ListRemindersAction {
@@ -29,38 +43,32 @@ func NewRemoveReminder() *RemoveReminderAction {
 	return &RemoveReminderAction{}
 }
 
-type ReminderAction struct{}
+type RecurringReminderAction struct{}
+type OneTimeReminderAction struct{}
 type ListRemindersAction struct{}
 type RemoveReminderAction struct{}
 
 type RemoveReminderParams struct {
 	Index int `json:"index"`
 }
 
-func (a *ReminderAction) Run(ctx context.Context, sharedState *types.AgentSharedState, params types.ActionParams) (types.ActionResult, error) {
-	result := types.ReminderActionResponse{}
+func (a *RecurringReminderAction) Run(ctx context.Context, sharedState *types.AgentSharedState, params types.ActionParams) (types.ActionResult, error) {
+	result := types.RecurringReminderParams{}
 	err := params.Unmarshal(&result)
 	if err != nil {
 		return types.ActionResult{}, err
 	}
 
-	// Create a scheduler task
-	scheduleType := scheduler.ScheduleTypeCron
-	if !result.IsRecurring {
-		scheduleType = scheduler.ScheduleTypeOnce
-	}
-
 	task, err := scheduler.NewTask(
 		sharedState.AgentName,
 		result.Message,
-		scheduleType,
+		scheduler.ScheduleTypeCron,
 		result.CronExpr,
 	)
 	if err != nil {
 		return types.ActionResult{}, err
 	}
 
-	// Store task ID in metadata for tracking
 	task.Metadata["reminder_type"] = "user_created"
 
 	err = sharedState.Scheduler.CreateTask(task)
@@ -69,15 +77,53 @@ func (a *ReminderAction) Run(ctx context.Context, sharedState *types.AgentShared
 	}
 
 	return types.ActionResult{
-		Result: fmt.Sprintf("Reminder set successfully (ID: %s)", task.ID),
+		Result: fmt.Sprintf("Recurring reminder set successfully (ID: %s). Next run: %s", task.ID, task.NextRun.Format(time.RFC3339)),
 		Metadata: map[string]interface{}{
-			"task_id":   task.ID,
-			"message":   result.Message,
-			"next_run":  task.NextRun,
-			"recurring": result.IsRecurring,
+			"task_id":  task.ID,
+			"message":  result.Message,
+			"next_run": task.NextRun,
 		},
 	}, nil
+}
+
+func (a *OneTimeReminderAction) Run(ctx context.Context, sharedState *types.AgentSharedState, params types.ActionParams) (types.ActionResult, error) {
+	result := types.OneTimeReminderParams{}
+	err := params.Unmarshal(&result)
+	if err != nil {
+		return types.ActionResult{}, err
+	}
 
+	// Validate the delay parses correctly before creating the task
+	_, err = scheduler.ParseDuration(result.Delay)
+	if err != nil {
+		return types.ActionResult{}, fmt.Errorf("invalid delay format, expected a duration like '30m', '2h', '1d', '1d12h': %w", err)
+	}
+
+	task, err := scheduler.NewTask(
+		sharedState.AgentName,
+		result.Message,
+		scheduler.ScheduleTypeOnce,
+		result.Delay,
+	)
+	if err != nil {
+		return types.ActionResult{}, err
+	}
+
+	task.Metadata["reminder_type"] = "user_created"
+
+	err = sharedState.Scheduler.CreateTask(task)
+	if err != nil {
+		return types.ActionResult{}, err
+	}
+
+	return types.ActionResult{
+		Result: fmt.Sprintf("One-time reminder set in %s (at %s, ID: %s)", result.Delay, task.NextRun.Format(time.RFC3339), task.ID),
+		Metadata: map[string]interface{}{
+			"task_id":  task.ID,
+			"message":  result.Message,
+			"next_run": task.NextRun,
+		},
+	}, nil
 }
 
 func (a *ListRemindersAction) Run(ctx context.Context, sharedState *types.AgentSharedState, params types.ActionParams) (types.ActionResult, error) {
@@ -155,7 +201,11 @@ func (a *RemoveReminderAction) Run(ctx context.Context, sharedState *types.Agent
 	}, nil
 }
 
-func (a *ReminderAction) Plannable() bool {
+func (a *RecurringReminderAction) Plannable() bool {
+	return true
+}
+
+func (a *OneTimeReminderAction) Plannable() bool {
 	return true
 }
 
@@ -167,10 +217,10 @@ func (a *RemoveReminderAction) Plannable() bool {
 	return true
 }
 
-func (a *ReminderAction) Definition() types.ActionDefinition {
+func (a *RecurringReminderAction) Definition() types.ActionDefinition {
 	return types.ActionDefinition{
-		Name:        ReminderActionName,
-		Description: "Set a reminder for the agent to wake up and perform a task based on a cron schedule. Examples: '0 0 * * *' (daily at midnight), '0 */2 * * *' (every 2 hours), '0 0 * * 1' (every Monday at midnight)",
+		Name:        RecurringReminderActionName,
+		Description: "Set a recurring reminder for the agent to wake up and perform a task on a cron schedule. The reminder will keep repeating. Examples: '0 0 * * *' (daily at midnight), '0 */2 * * *' (every 2 hours), '0 0 * * 1' (every Monday at midnight)",
 		Properties: map[string]jsonschema.Definition{
 			"message": {
 				Type:        jsonschema.String,
@@ -180,12 +230,26 @@ func (a *ReminderAction) Definition() types.ActionDefinition {
 				Type:        jsonschema.String,
 				Description: "Cron expression for scheduling (e.g. '0 0 * * *' for daily at midnight). Format: 'minute hour day month weekday'",
 			},
-			"is_recurring": {
-				Type:        jsonschema.Boolean,
-				Description: "Whether this reminder should repeat according to the cron schedule (true) or trigger only once (false)",
+		},
+		Required: []string{"message", "cron_expr"},
+	}
+}
+
+func (a *OneTimeReminderAction) Definition() types.ActionDefinition {
+	return types.ActionDefinition{
+		Name:        OneTimeReminderActionName,
+		Description: "Set a one-time reminder for the agent to wake up and perform a task after a delay. The reminder triggers only once and is then automatically removed. Use this when asked to do something 'in X minutes/hours/days'. Examples: '30m' (30 minutes), '2h' (2 hours), '1d' (1 day), '1d12h' (1.5 days), '2h30m' (2.5 hours)",
+		Properties: map[string]jsonschema.Definition{
+			"message": {
+				Type:        jsonschema.String,
+				Description: "The message or task to be reminded about",
+			},
+			"delay": {
+				Type:        jsonschema.String,
+				Description: "How long to wait before triggering. Use Go duration format: '30m' (30 minutes), '2h' (2 hours), '1d' (1 day), '1d12h' (1.5 days), '2h30m' (2.5 hours)",
 			},
 		},
-		Required: []string{"message", "cron_expr", "is_recurring"},
+		Required: []string{"message", "delay"},
 	}
 }
 

core/scheduler/scheduler_test.go

@@ -78,11 +78,27 @@ var _ = Describe("Scheduler", func() {
 			Expect(task.NextRun).To(BeTemporally("~", time.Now().Add(time.Hour), 5*time.Second))
 		})
 
-		It("should create a valid task with once schedule", func() {
-			futureTime := time.Now().Add(24 * time.Hour)
-			task, err := scheduler.NewTask("test-agent", "test prompt", scheduler.ScheduleTypeOnce, futureTime.Format(time.RFC3339))
+		It("should create a valid task with once schedule using duration", func() {
+			task, err := scheduler.NewTask("test-agent", "test prompt", scheduler.ScheduleTypeOnce, "24h")
 			Expect(err).NotTo(HaveOccurred())
-			Expect(task.NextRun).To(BeTemporally("~", futureTime, time.Second))
+			Expect(task.NextRun).To(BeTemporally("~", time.Now().Add(24*time.Hour), 5*time.Second))
+		})
+
+		It("should create a valid task with once schedule using day syntax", func() {
+			task, err := scheduler.NewTask("test-agent", "test prompt", scheduler.ScheduleTypeOnce, "1d")
+			Expect(err).NotTo(HaveOccurred())
+			Expect(task.NextRun).To(BeTemporally("~", time.Now().Add(24*time.Hour), 5*time.Second))
+		})
+
+		It("should create a valid task with once schedule using combined day+time", func() {
+			task, err := scheduler.NewTask("test-agent", "test prompt", scheduler.ScheduleTypeOnce, "2d12h30m")
+			Expect(err).NotTo(HaveOccurred())
+			Expect(task.NextRun).To(BeTemporally("~", time.Now().Add(2*24*time.Hour+12*time.Hour+30*time.Minute), 5*time.Second))
+		})
+
+		It("should return error for invalid once duration", func() {
+			_, err := scheduler.NewTask("test-agent", "test prompt", scheduler.ScheduleTypeOnce, "invalid")
+			Expect(err).To(HaveOccurred())
 		})
 	})
 
@@ -161,11 +177,15 @@ var _ = Describe("Scheduler", func() {
 		Context("Querying tasks", func() {
 			BeforeEach(func() {
 				// Create test tasks
-				task1, err := scheduler.NewTask("agent1", "prompt1", scheduler.ScheduleTypeOnce, time.Now().Add(-1*time.Hour).Format(time.RFC3339))
+				// task1: once schedule with 0s delay => immediately due
+				task1, err := scheduler.NewTask("agent1", "prompt1", scheduler.ScheduleTypeOnce, "0s")
 				Expect(err).NotTo(HaveOccurred())
-				task2, err := scheduler.NewTask("agent2", "prompt2", scheduler.ScheduleTypeOnce, time.Now().Add(1*time.Hour).Format(time.RFC3339))
+				task1.NextRun = time.Now().Add(-1 * time.Hour) // force into the past
+				// task2: cron schedule => next run in the future, not due
+				task2, err := scheduler.NewTask("agent2", "prompt2", scheduler.ScheduleTypeCron, "0 0 1 1 *")
 				Expect(err).NotTo(HaveOccurred())
-				task3, err := scheduler.NewTask("agent1", "prompt3", scheduler.ScheduleTypeOnce, time.Now().Add(-1*time.Hour).Format(time.RFC3339))
+				// task3: once schedule but paused => not due
+				task3, err := scheduler.NewTask("agent1", "prompt3", scheduler.ScheduleTypeOnce, "0s")
 				Expect(err).NotTo(HaveOccurred())
 				task3.Status = scheduler.TaskStatusPaused
 
@@ -251,7 +271,8 @@ var _ = Describe("Scheduler", func() {
 
 	Describe("Scheduler Execution", func() {
 		It("should execute a due task", func() {
-			task, _ := scheduler.NewTask("test-agent", "test prompt", scheduler.ScheduleTypeOnce, time.Now().Add(-1*time.Second).Format(time.RFC3339))
+			task, _ := scheduler.NewTask("test-agent", "test prompt", scheduler.ScheduleTypeOnce, "0s")
+			task.NextRun = time.Now().Add(-1 * time.Second) // force into the past
 			err := sched.CreateTask(task)
 			Expect(err).NotTo(HaveOccurred())
 
@@ -294,7 +315,8 @@ var _ = Describe("Scheduler", func() {
 
 		It("should handle task execution errors", func() {
 			executor.shouldError = true
-			task, _ := scheduler.NewTask("test-agent", "error task", scheduler.ScheduleTypeOnce, time.Now().Add(-1*time.Second).Format(time.RFC3339))
+			task, _ := scheduler.NewTask("test-agent", "error task", scheduler.ScheduleTypeOnce, "0s")
+			task.NextRun = time.Now().Add(-1 * time.Second) // force into the past
 			sched.CreateTask(task)
 
 			// Scheduler is already started in BeforeEach
@@ -310,7 +332,8 @@ var _ = Describe("Scheduler", func() {
 		})
 
 		It("should not execute paused tasks", func() {
-			task, _ := scheduler.NewTask("test-agent", "paused", scheduler.ScheduleTypeOnce, time.Now().Add(-1*time.Second).Format(time.RFC3339))
+			task, _ := scheduler.NewTask("test-agent", "paused", scheduler.ScheduleTypeOnce, "0s")
+			task.NextRun = time.Now().Add(-1 * time.Second) // force into the past
 			task.Status = scheduler.TaskStatusPaused
 			sched.CreateTask(task)
 

core/scheduler/task.go

@@ -2,13 +2,37 @@ package scheduler
 
 import (
 	"fmt"
+	"regexp"
 	"strconv"
 	"time"
 
 	"github.com/google/uuid"
 	"github.com/robfig/cron/v3"
 )
 
+var dayPattern = regexp.MustCompile(`^(\d+)d(.*)$`)
+
+// ParseDuration extends time.ParseDuration with support for days ("d").
+// Examples: "1d" = 24h, "2d12h" = 60h, "30m", "2h30m".
+func ParseDuration(s string) (time.Duration, error) {
+	if m := dayPattern.FindStringSubmatch(s); m != nil {
+		days, err := strconv.Atoi(m[1])
+		if err != nil {
+			return 0, fmt.Errorf("invalid duration: %s", s)
+		}
+		d := time.Duration(days) * 24 * time.Hour
+		if m[2] != "" {
+			rest, err := time.ParseDuration(m[2])
+			if err != nil {
+				return 0, fmt.Errorf("invalid duration: %w", err)
+			}
+			d += rest
+		}
+		return d, nil
+	}
+	return time.ParseDuration(s)
+}
+
 type TaskStatus string
 
 const (
@@ -78,7 +102,7 @@ func (t *Task) CalculateNextRun() error {
 	now := time.Now()
 
 	switch t.ScheduleType {
-	case ScheduleTypeCron, ScheduleTypeOnce:
+	case ScheduleTypeCron:
 		parser := cron.NewParser(cron.Minute | cron.Hour | cron.Dom | cron.Month | cron.Dow)
 		schedule, err := parser.Parse(t.ScheduleValue)
 		if err != nil {
@@ -100,12 +124,15 @@ func (t *Task) CalculateNextRun() error {
 			t.NextRun = now.Add(time.Duration(intervalMs) * time.Millisecond)
 		}
 
-	// case ScheduleTypeOnce:
-	// 	nextRun, err := time.Parse(time.RFC3339, t.ScheduleValue)
-	// 	if err != nil {
-	// 		return fmt.Errorf("invalid timestamp: %w", err)
-	// 	}
-	// 	t.NextRun = nextRun
+	case ScheduleTypeOnce:
+		duration, err := ParseDuration(t.ScheduleValue)
+		if err != nil {
+			return fmt.Errorf("invalid duration: %w", err)
+		}
+		if duration < 0 {
+			return fmt.Errorf("duration must be positive: %s", t.ScheduleValue)
+		}
+		t.NextRun = now.Add(duration)
 
 	default:
 		return fmt.Errorf("unknown schedule type: %s", t.ScheduleType)

core/types/state.go

@@ -40,14 +40,22 @@ const (
 	DefaultLastMessageDuration = 5 * time.Minute
 )
 
-type ReminderActionResponse struct {
-	Message     string    `json:"message"`
-	CronExpr    string    `json:"cron_expr"`    // Cron expression for scheduling
-	LastRun     time.Time `json:"last_run"`     // Last time this reminder was triggered
-	NextRun     time.Time `json:"next_run"`     // Next scheduled run time
-	IsRecurring bool      `json:"is_recurring"` // Whether this is a recurring reminder
+// RecurringReminderParams are the parameters the LLM provides for set_recurring_reminder.
+type RecurringReminderParams struct {
+	Message  string `json:"message"`
+	CronExpr string `json:"cron_expr"`
 }
 
+// OneTimeReminderParams are the parameters the LLM provides for set_onetime_reminder.
+type OneTimeReminderParams struct {
+	Message string `json:"message"`
+	Delay   string `json:"delay"` // Go duration format with day support: "30m", "2h", "1d", "1d12h"
+}
+
+// ReminderActionResponse is kept for backward compatibility.
+// Deprecated: use RecurringReminderParams or OneTimeReminderParams.
+type ReminderActionResponse = RecurringReminderParams
+
 type AgentSharedState struct {
 	ConversationTracker *conversations.ConversationTracker[string] `json:"conversation_tracker"`
 	Scheduler           TaskScheduler                              `json:"-"` // Not serialized, set at runtime