Split alarms and timers completely.

Katharine · Katharine · commit 61c77659ef03 · 2025-03-21T14:54:36.000-07:00
Signed-off-by: Katharine Berry &lt;ktbry@google.com&gt;
diff --git a/service/assistant/functions/alarms.go b/service/assistant/functions/alarms.go
@@ -26,58 +26,49 @@ import (
 )
 
 type AlarmInput struct {
-	// If setting an alarm, the time to schedule the alarm for in ISO 8601 format, e.g. '2023-07-12T00:00:00-07:00'. Required for alarms. Must always be in the future.
+	// The time to schedule the alarm for in ISO 8601 format, e.g. '2023-07-12T00:00:00-07:00'. Must always be in the future.
 	Time string `json:"time"`
+	// An optional name for the alarm.
+	Name string `json:"name"`
+}
+
+type TimerInput struct {
 	// If setting a timer, the number of seconds to set the timer for. Required for timers.
 	Duration int `json:"duration_seconds"`
-	// True if this is a timer, false if it's an alarm.
-	IsTimer bool `json:"is_timer" jsonschema:"required"`
 	// An optional name for the alarm or timer.
 	Name string `json:"name"`
 }
 
 type DeleteAlarmInput struct {
-	// The time of the alarm or timer to delete in ISO 8601 format, e.g. '2023-07-12T00:00:00-07:00'.
+	// The time of the alarm to delete in ISO 8601 format, e.g. '2023-07-12T00:00:00-07:00'.
 	Time string `json:"time"`
-	// True if deleting a timer, false if deleting an alarm.
-	IsTimer bool `json:"is_timer"`
 }
 
-type GetAlarmInput struct {
-	// True if retrieving timers, false if returning alarms.
-	IsTimer bool `json:"is_timer" jsonschema:"required"`
+type DeleteTimerInput struct {
+	// The expiration time of the timer to delete in ISO 8601 format, e.g. '2023-07-12T00:00:00-07:00'.
+	Time string `json:"time"`
 }
 
+type Empty struct{}
+
 func init() {
 	params := genai.Schema{
 		Type:     genai.TypeObject,
 		Nullable: false,
 		Properties: map[string]*genai.Schema{
 			"time": {
 				Type:        genai.TypeString,
-				Description: "If setting an alarm, the time to schedule the alarm for in ISO 8601 format, e.g. '2023-07-12T00:00:00-07:00'. Required for alarms. Must always be in the future.",
+				Description: "The time to schedule the alarm for in ISO 8601 format, e.g. '2023-07-12T00:00:00-07:00'. Must always be in the future.",
 				Nullable:    true,
 			},
-			"duration_seconds": {
-				Type:        genai.TypeInteger,
-				Description: "If setting a timer, the number of seconds to set the timer for. Required for timers.",
-				Nullable:    true,
-				Format:      "int32",
-			},
-			"is_timer": {
-				Type:        genai.TypeBoolean,
-				Description: "True if this is a timer, false if it's an alarm.",
-				Nullable:    false,
-			},
 		},
-		Required: []string{"is_timer"},
 	}
 	// This registration is for old watch apps that don't support named alarms. The anticapability prevents it
 	// from being seen by newer apps.
 	registerFunction(Registration{
 		Definition: genai.FunctionDeclaration{
 			Name:        "set_alarm",
-			Description: "Get or set an alarm or a timer for a given time.",
+			Description: "Set an alarm for a given time.",
 			Parameters:  &params,
 		},
 		Cb:             alarmImpl,
@@ -90,15 +81,15 @@ func init() {
 	paramsWithNames.Properties = maps.Clone(params.Properties)
 	paramsWithNames.Properties["name"] = &genai.Schema{
 		Type:        genai.TypeString,
-		Description: "Only if explicitly specified by the user, the name of the alarm or timer. Use title case. If the user didn't ask to name the timer, just leave it empty.",
+		Description: "Only if explicitly specified by the user, the name of the alarm. Use title case. If the user didn't ask to name the alarm, just leave it empty.",
 		Nullable:    true,
 	}
 	// This registration is for new watch apps that support named alarms. The capability prevents the option for
 	// naming being presented to the model for older apps.
 	registerFunction(Registration{
 		Definition: genai.FunctionDeclaration{
 			Name:        "set_alarm",
-			Description: "Get or set an alarm or a timer for a given time.",
+			Description: "Set an alarm for a given time.",
 			Parameters:  &paramsWithNames,
 		},
 		Cb:         alarmImpl,
@@ -110,65 +101,142 @@ func init() {
 	registerFunction(Registration{
 		Definition: genai.FunctionDeclaration{
 			Name:        "get_alarms",
-			Description: "Get any existing alarms or timers. **There is no get_timers, call this with is_timer=true instead.**",
+			Description: "Get any existing alarms.",
+		},
+		Aliases:   []string{"get_alarm"},
+		Cb:        getAlarmImpl,
+		Thought:   getAlarmThought,
+		InputType: Empty{},
+	})
+
+	registerFunction(Registration{
+		Definition: genai.FunctionDeclaration{
+			Name:        "delete_alarm",
+			Description: "Delete a specific alarm by its expiration time.",
 			Parameters: &genai.Schema{
 				Type:     genai.TypeObject,
 				Nullable: false,
 				Properties: map[string]*genai.Schema{
-					"is_timer": {
-						Type:        genai.TypeBoolean,
-						Description: "True if retrieving timers, false if returning alarms.",
+					"time": {
+						Type:        genai.TypeString,
+						Description: "The time of the alarm to delete in ISO 8601 format, e.g. '2023-07-12T00:00:00-07:00'.",
 						Nullable:    false,
 					},
 				},
-				Required: []string{"is_timer"},
 			},
 		},
-		Aliases:   []string{"get_alarms", "get_timer", "get_timers"},
-		Cb:        getAlarmImpl,
-		Thought:   getAlarmThought,
-		InputType: GetAlarmInput{},
+		Cb:        deleteAlarmImpl,
+		Thought:   deleteAlarmThought,
+		InputType: DeleteAlarmInput{},
+	})
+	timerParams := genai.Schema{
+		Type:     genai.TypeObject,
+		Nullable: false,
+		Properties: map[string]*genai.Schema{
+			"duration_seconds": {
+				Type:        genai.TypeInteger,
+				Description: "The number of seconds to set the timer for.",
+				Nullable:    true,
+				Format:      "int32",
+			},
+		},
+	}
+	// This registration is for old watch apps that don't support named alarms. The anticapability prevents it
+	// from being seen by newer apps.
+	registerFunction(Registration{
+		Definition: genai.FunctionDeclaration{
+			Name:        "set_timer",
+			Description: "Set a timer for a given duration.",
+			Parameters:  &timerParams,
+		},
+		Cb:             timerImpl,
+		Thought:        timerThought,
+		InputType:      TimerInput{},
+		AntiCapability: "named_alarms",
+	})
+	timerParamsWithNames := timerParams
+	timerParamsWithNames.Properties = maps.Clone(timerParams.Properties)
+	timerParamsWithNames.Properties["name"] = &genai.Schema{
+		Type:        genai.TypeString,
+		Description: "Only if explicitly specified by the user, the name of the timer. Use title case. If the user didn't ask to name the timer, just leave it empty.",
+		Nullable:    true,
+	}
+	registerFunction(Registration{
+		Definition: genai.FunctionDeclaration{
+			Name:        "set_timer",
+			Description: "Set a timer for a given time.",
+			Parameters:  &timerParamsWithNames,
+		},
+		Cb:         timerImpl,
+		Thought:    timerThought,
+		InputType:  TimerInput{},
+		Capability: "named_alarms",
 	})
 
 	registerFunction(Registration{
 		Definition: genai.FunctionDeclaration{
-			Name:        "delete_alarm",
-			Description: "Delete a specific alarm or timer by its expiration time. When deleting a timer, you must call get_alarm first to get the expiration time (calculating it from the chat history will only be approximate)",
+			Name:        "get_timers",
+			Description: "Get any existing timers.",
+		},
+		Aliases:   []string{"get_timer"},
+		Cb:        getTimerImpl,
+		Thought:   getTimerThought,
+		InputType: Empty{},
+	})
+
+	registerFunction(Registration{
+		Definition: genai.FunctionDeclaration{
+			Name:        "delete_timer",
+			Description: "Delete a specific timer by its expiration time.",
 			Parameters: &genai.Schema{
 				Type:     genai.TypeObject,
 				Nullable: false,
 				Properties: map[string]*genai.Schema{
 					"time": {
 						Type:        genai.TypeString,
-						Description: "The time of the alarm or timer to delete in ISO 8601 format, e.g. '2023-07-12T00:00:00-07:00'.",
-						Nullable:    false,
-					},
-					"is_timer": {
-						Type:        genai.TypeBoolean,
-						Description: "True if deleting a timer, false if deleting an alarm.",
+						Description: "The time of the alarm to delete in ISO 8601 format, e.g. '2023-07-12T00:00:00-07:00'.",
 						Nullable:    false,
 					},
 				},
 			},
 		},
-		Cb:        deleteAlarmImpl,
-		Thought:   deleteAlarmThought,
-		InputType: DeleteAlarmInput{},
+		Cb:        deleteTimerImpl,
+		Thought:   deleteTimerThought,
+		InputType: DeleteTimerInput{},
 	})
 }
 
 func alarmImpl(ctx context.Context, quotaTracker *quota.Tracker, args interface{}, requests chan<- map[string]interface{}, responses <-chan map[string]interface{}) interface{} {
 	ctx, span := beeline.StartSpan(ctx, "set_alarm")
 	defer span.Send()
 	if !query.SupportsAction(ctx, "set_alarm") {
-		return Error{Error: "You need to update the app on your watch to set alarms or timers."}
+		return Error{Error: "You need to update the app on your watch to set alarms."}
 	}
 	input := args.(*AlarmInput)
 	log.Println("Asking watch to set an alarm...")
 	requests <- map[string]interface{}{
-		"time":     input.Time,
+		"time":    input.Time,
+		"isTimer": false,
+		"name":    input.Name,
+		"action":  "set_alarm",
+		"cancel":  false,
+	}
+	log.Println("Waiting for confirmation...")
+	resp := <-responses
+	return resp
+}
+
+func timerImpl(ctx context.Context, quotaTracker *quota.Tracker, args interface{}, requests chan<- map[string]interface{}, responses <-chan map[string]interface{}) interface{} {
+	ctx, span := beeline.StartSpan(ctx, "set_timer")
+	defer span.Send()
+	if !query.SupportsAction(ctx, "set_alarm") {
+		return Error{Error: "You need to update the app on your watch to set timers."}
+	}
+	input := args.(*TimerInput)
+	log.Println("Asking watch to set an alarm...")
+	requests <- map[string]interface{}{
 		"duration": input.Duration,
-		"isTimer":  input.IsTimer,
+		"isTimer":  true,
 		"name":     input.Name,
 		"action":   "set_alarm",
 		"cancel":   false,
@@ -180,26 +248,33 @@ func alarmImpl(ctx context.Context, quotaTracker *quota.Tracker, args interface{
 
 func alarmThought(i interface{}) string {
 	args := i.(*AlarmInput)
-	if args.IsTimer {
-		return "Setting a timer"
-	} else if args.Time == "" {
+	if args.Time == "" {
 		return "Contemplating time"
 	} else {
 		return "Setting an alarm"
 	}
 }
 
+func timerThought(i interface{}) string {
+	args := i.(*TimerInput)
+	if args.Duration == 0 {
+		return "Contemplating time"
+	} else {
+		return "Setting a timer"
+	}
+}
+
 func deleteAlarmImpl(ctx context.Context, quotaTracker *quota.Tracker, args interface{}, requests chan<- map[string]interface{}, responses <-chan map[string]interface{}) interface{} {
-	ctx, span := beeline.StartSpan(ctx, "set_alarm")
+	ctx, span := beeline.StartSpan(ctx, "delete_alarm")
 	defer span.Send()
 	if !query.SupportsAction(ctx, "set_alarm") {
-		return Error{Error: "You need to update the app on your watch to delete alarms or timers."}
+		return Error{Error: "You need to update the app on your watch to delete alarms."}
 	}
 	input := args.(*DeleteAlarmInput)
 	log.Printf("Asking watch to delete an alarm set for %s...\n", input.Time)
 	requests <- map[string]interface{}{
 		"time":    input.Time,
-		"isTimer": input.IsTimer,
+		"isTimer": false,
 		"action":  "set_alarm",
 		"cancel":  true,
 	}
@@ -208,25 +283,42 @@ func deleteAlarmImpl(ctx context.Context, quotaTracker *quota.Tracker, args inte
 	return resp
 }
 
-func deleteAlarmThought(i interface{}) string {
-	args := i.(*DeleteAlarmInput)
-	if args.IsTimer {
-		return "Deleting a timer"
-	} else {
-		return "Deleting an alarm"
+func deleteTimerImpl(ctx context.Context, quotaTracker *quota.Tracker, args interface{}, requests chan<- map[string]interface{}, responses <-chan map[string]interface{}) interface{} {
+	ctx, span := beeline.StartSpan(ctx, "delete_timer")
+	defer span.Send()
+	if !query.SupportsAction(ctx, "set_alarm") {
+		return Error{Error: "You need to update the app on your watch to delete timers."}
 	}
+	input := args.(*DeleteTimerInput)
+	log.Printf("Asking watch to delete a timer set for %s...\n", input.Time)
+	requests <- map[string]interface{}{
+		"time":    input.Time,
+		"isTimer": true,
+		"action":  "set_alarm",
+		"cancel":  true,
+	}
+	log.Println("Waiting for confirmation...")
+	resp := <-responses
+	return resp
+}
+
+func deleteAlarmThought(i interface{}) string {
+	return "Deleting an alarm"
+}
+
+func deleteTimerThought(i interface{}) string {
+	return "Deleting a timer"
 }
 
 func getAlarmImpl(ctx context.Context, quotaTracker *quota.Tracker, args interface{}, requests chan<- map[string]interface{}, responses <-chan map[string]interface{}) interface{} {
 	ctx, span := beeline.StartSpan(ctx, "get_alarm")
 	defer span.Send()
 	if !query.SupportsAction(ctx, "get_alarm") {
-		return Error{Error: "You need to update the app on your watch to get alarms or timers."}
+		return Error{Error: "You need to update the app on your watch to get alarms."}
 	}
-	input := args.(*GetAlarmInput)
 	log.Println("Asking watch to get alarms...")
 	requests <- map[string]interface{}{
-		"isTimer": input.IsTimer,
+		"isTimer": false,
 		"action":  "get_alarm",
 	}
 	log.Println("Waiting for response...")
@@ -235,10 +327,27 @@ func getAlarmImpl(ctx context.Context, quotaTracker *quota.Tracker, args interfa
 	return resp
 }
 
-func getAlarmThought(i interface{}) string {
-	args := i.(*GetAlarmInput)
-	if args.IsTimer {
-		return "Checking your timers"
+func getTimerImpl(ctx context.Context, quotaTracker *quota.Tracker, args interface{}, requests chan<- map[string]interface{}, responses <-chan map[string]interface{}) interface{} {
+	ctx, span := beeline.StartSpan(ctx, "get_timer")
+	defer span.Send()
+	if !query.SupportsAction(ctx, "get_alarm") {
+		return Error{Error: "You need to update the app on your watch to get timers."}
 	}
+	log.Println("Asking watch to get alarms...")
+	requests <- map[string]interface{}{
+		"isTimer": true,
+		"action":  "get_alarm",
+	}
+	log.Println("Waiting for response...")
+	resp := <-responses
+	log.Println("Got response:", resp)
+	return resp
+}
+
+func getAlarmThought(i interface{}) string {
 	return "Checking your alarms"
 }
+
+func getTimerThought(i interface{}) string {
+	return "Checking your timers"
+}
diff --git a/service/assistant/system_prompt.go b/service/assistant/system_prompt.go
@@ -119,7 +119,7 @@ func (ps *PromptSession) generateSystemPrompt(ctx context.Context) string {
 		"As a creative, intelligent, helpful, friendly assistant, you should always try to answer the user's question. You can and should provide creative suggestions and factual responses as appropriate. Always try your best to answer the user's question. " +
 		"**Never** claim to have taken an action (e.g. set a timer, alarm, or reminder) unless you have actually used a tool to do so. " +
 		"Even if in previous turns you have apparently taken an action (like setting an alarm) without using a tool, you must still use tools if asked to do so again. " +
-		"Alarms and reminders are not interchangable - *never* use alarms when a user asks for reminders, and never user reminders when the user asks for an alarm or timer. If a user asks to set a timer, always set a timer (using 'set_alarm'). If the user asks about a specific timer, respond only about that one. " +
+		"Alarms and reminders are not interchangable - *never* use alarms when a user asks for reminders, and never user reminders when the user asks for an alarm or timer. If a user asks to set a timer, always set a timer (using 'set_timer'), not a reminder. If the user asks about a specific timer, respond only about that one. " +
 		"Your responses will be displayed on a very small screen, so be brief. Do not use markdown in your responses.\n" +
 		//"If asked to perform a calculation, YOU MUST ALWAYS respond with the answer. The user cannot see the results of calling functions automatically.\n" +
 		generateWidgetSentence(ctx) +
diff --git a/service/assistant/verifier/verifier.go b/service/assistant/verifier/verifier.go
