feat(chatd): use last assistant message as push notification summary (#22671)

Instead of the static 'Agent has finished running.' text, extract a summary from the last assistant message to give users meaningful context about what the agent accomplished. Falls back to the static text if no suitable message is found. Co-authored-by: Kyle Carberry <kyle@carberry.com>
2026-09-24 15:04:27 +08:00 · 2026-03-10 15:14:15 +00:00
parent 12bdbc693f
commit 6489d6f714
10 changed files with 347 additions and 56 deletions
@@ -0,0 +1,347 @@
+package chatd
+
+import (
+	"context"
+	"strings"
+	"time"
+
+	"charm.land/fantasy"
+	fantasyanthropic "charm.land/fantasy/providers/anthropic"
+	fantasyazure "charm.land/fantasy/providers/azure"
+	fantasybedrock "charm.land/fantasy/providers/bedrock"
+	fantasygoogle "charm.land/fantasy/providers/google"
+	fantasyopenai "charm.land/fantasy/providers/openai"
+	fantasyopenrouter "charm.land/fantasy/providers/openrouter"
+	fantasyvercel "charm.land/fantasy/providers/vercel"
+	"golang.org/x/xerrors"
+
+	"cdr.dev/slog/v3"
+	"github.com/coder/coder/v2/coderd/chatd/chatprompt"
+	"github.com/coder/coder/v2/coderd/chatd/chatprovider"
+	"github.com/coder/coder/v2/coderd/chatd/chatretry"
+	"github.com/coder/coder/v2/coderd/database"
+	coderdpubsub "github.com/coder/coder/v2/coderd/pubsub"
+)
+
+const titleGenerationPrompt = "Generate a concise title (2-8 words) for the user's message. " +
+	"Use verb-noun format describing the primary intent (e.g. \"Fix sidebar layout\", " +
+	"\"Add user authentication\", \"Refactor database queries\"). " +
+	"Return plain text only — no quotes, no emoji, no markdown, no code fences, " +
+	"no special characters, no trailing punctuation. Sentence case."
+
+// preferredTitleModels are lightweight models used for title
+// generation, one per provider type. Each entry uses the
+// cheapest/fastest small model for that provider as identified
+// by the charmbracelet/catwalk model catalog. Providers that
+// aren't configured (no API key) are silently skipped.
+var preferredTitleModels = []struct {
+	provider string
+	model    string
+}{
+	{fantasyanthropic.Name, "claude-haiku-4-5"},
+	{fantasyopenai.Name, "gpt-4o-mini"},
+	{fantasygoogle.Name, "gemini-2.5-flash"},
+	{fantasyazure.Name, "gpt-4o-mini"},
+	{fantasybedrock.Name, "anthropic.claude-haiku-4-5-20251001-v1:0"},
+	{fantasyopenrouter.Name, "anthropic/claude-3.5-haiku"},
+	{fantasyvercel.Name, "anthropic/claude-haiku-4.5"},
+}
+
+// maybeGenerateChatTitle generates an AI title for the chat when
+// appropriate (first user message, no assistant reply yet, and the
+// current title is either empty or still the fallback truncation).
+// It tries cheap, fast models first and falls back to the user's
+// chat model. It is a best-effort operation that logs and swallows
+// errors.
+func (p *Server) maybeGenerateChatTitle(
+	ctx context.Context,
+	chat database.Chat,
+	messages []database.ChatMessage,
+	fallbackModel fantasy.LanguageModel,
+	keys chatprovider.ProviderAPIKeys,
+	logger slog.Logger,
+) {
+	input, ok := titleInput(chat, messages)
+	if !ok {
+		return
+	}
+
+	titleCtx, cancel := context.WithTimeout(ctx, 30*time.Second)
+	defer cancel()
+
+	// Build candidate list: preferred lightweight models first,
+	// then the user's chat model as last resort.
+	candidates := make([]fantasy.LanguageModel, 0, len(preferredTitleModels)+1)
+	for _, c := range preferredTitleModels {
+		m, err := chatprovider.ModelFromConfig(
+			c.provider, c.model, keys,
+		)
+		if err == nil {
+			candidates = append(candidates, m)
+		}
+	}
+	candidates = append(candidates, fallbackModel)
+	var lastErr error
+	for _, model := range candidates {
+		title, err := generateTitle(titleCtx, model, input)
+		if err != nil {
+			lastErr = err
+			logger.Debug(ctx, "title model candidate failed",
+				slog.F("chat_id", chat.ID),
+				slog.Error(err),
+			)
+			continue
+		}
+		if title == "" || title == chat.Title {
+			return
+		}
+
+		_, err = p.db.UpdateChatByID(ctx, database.UpdateChatByIDParams{
+			ID:    chat.ID,
+			Title: title,
+		})
+		if err != nil {
+			logger.Warn(ctx, "failed to update generated chat title",
+				slog.F("chat_id", chat.ID),
+				slog.Error(err),
+			)
+			return
+		}
+		chat.Title = title
+		p.publishChatPubsubEvent(chat, coderdpubsub.ChatEventKindTitleChange)
+		return
+	}
+
+	if lastErr != nil {
+		logger.Debug(ctx, "all title model candidates failed",
+			slog.F("chat_id", chat.ID),
+			slog.Error(lastErr),
+		)
+	}
+}
+
+// generateTitle calls the model with a title-generation system prompt
+// and returns the normalized result. It retries transient LLM errors
+// (rate limits, overloaded, etc.) with exponential backoff.
+func generateTitle(
+	ctx context.Context,
+	model fantasy.LanguageModel,
+	input string,
+) (string, error) {
+	title, err := generateShortText(ctx, model, titleGenerationPrompt, input)
+	if err != nil {
+		return "", err
+	}
+	title = normalizeTitleOutput(title)
+	if title == "" {
+		return "", xerrors.New("generated title was empty")
+	}
+	return title, nil
+}
+
+// titleInput returns the first user message text and whether title
+// generation should proceed. It returns false when the chat already
+// has assistant/tool replies, has more than one visible user message,
+// or the current title doesn't look like a candidate for replacement.
+func titleInput(
+	chat database.Chat,
+	messages []database.ChatMessage,
+) (string, bool) {
+	userCount := 0
+	firstUserText := ""
+
+	for _, message := range messages {
+		if message.Visibility == database.ChatMessageVisibilityModel {
+			continue
+		}
+
+		switch message.Role {
+		case string(fantasy.MessageRoleAssistant), string(fantasy.MessageRoleTool):
+			return "", false
+		case string(fantasy.MessageRoleUser):
+			userCount++
+			if firstUserText == "" {
+				parsed, err := chatprompt.ParseContent(
+					string(fantasy.MessageRoleUser), message.Content,
+				)
+				if err != nil {
+					return "", false
+				}
+				firstUserText = strings.TrimSpace(
+					contentBlocksToText(parsed),
+				)
+			}
+		}
+	}
+
+	if userCount != 1 || firstUserText == "" {
+		return "", false
+	}
+
+	currentTitle := strings.TrimSpace(chat.Title)
+	if currentTitle == "" {
+		return firstUserText, true
+	}
+
+	if currentTitle != fallbackChatTitle(firstUserText) {
+		return "", false
+	}
+
+	return firstUserText, true
+}
+
+func normalizeTitleOutput(title string) string {
+	title = strings.TrimSpace(title)
+	if title == "" {
+		return ""
+	}
+
+	title = strings.Trim(title, "\"'`")
+	title = strings.Join(strings.Fields(title), " ")
+	return truncateRunes(title, 80)
+}
+
+func fallbackChatTitle(message string) string {
+	const maxWords = 6
+	const maxRunes = 80
+
+	words := strings.Fields(message)
+	if len(words) == 0 {
+		return "New Chat"
+	}
+
+	truncated := false
+	if len(words) > maxWords {
+		words = words[:maxWords]
+		truncated = true
+	}
+
+	title := strings.Join(words, " ")
+	if truncated {
+		title += "…"
+	}
+
+	return truncateRunes(title, maxRunes)
+}
+
+// contentBlocksToText concatenates the text parts of content blocks
+// into a single space-separated string.
+func contentBlocksToText(content []fantasy.Content) string {
+	parts := make([]string, 0, len(content))
+	for _, block := range content {
+		textBlock, ok := fantasy.AsContentType[fantasy.TextContent](block)
+		if !ok {
+			continue
+		}
+		text := strings.TrimSpace(textBlock.Text)
+		if text == "" {
+			continue
+		}
+		parts = append(parts, text)
+	}
+	return strings.Join(parts, " ")
+}
+
+func truncateRunes(value string, maxLen int) string {
+	if maxLen <= 0 {
+		return ""
+	}
+	runes := []rune(value)
+	if len(runes) <= maxLen {
+		return value
+	}
+	return string(runes[:maxLen])
+}
+
+const pushSummaryPrompt = "You are a notification assistant. Given a chat title " +
+	"and the agent's last message, write a single short sentence (under 100 characters) " +
+	"summarizing what the agent did. This will be shown as a push notification body. " +
+	"Return plain text only — no quotes, no emoji, no markdown."
+
+// generatePushSummary calls a cheap model to produce a short push
+// notification body from the chat title and the last assistant
+// message text. It follows the same candidate-selection strategy
+// as title generation: try preferred lightweight models first, then
+// fall back to the provided model. Returns "" on any failure.
+func generatePushSummary(
+	ctx context.Context,
+	chatTitle string,
+	assistantText string,
+	fallbackModel fantasy.LanguageModel,
+	keys chatprovider.ProviderAPIKeys,
+	logger slog.Logger,
+) string {
+	summaryCtx, cancel := context.WithTimeout(ctx, 30*time.Second)
+	defer cancel()
+
+	input := "Chat title: " + chatTitle + "\n\nAgent's last message:\n" + assistantText
+
+	candidates := make([]fantasy.LanguageModel, 0, len(preferredTitleModels)+1)
+	for _, c := range preferredTitleModels {
+		m, err := chatprovider.ModelFromConfig(
+			c.provider, c.model, keys,
+		)
+		if err == nil {
+			candidates = append(candidates, m)
+		}
+	}
+	candidates = append(candidates, fallbackModel)
+
+	for _, model := range candidates {
+		summary, err := generateShortText(summaryCtx, model, pushSummaryPrompt, input)
+		if err != nil {
+			logger.Debug(ctx, "push summary model candidate failed",
+				slog.Error(err),
+			)
+			continue
+		}
+		if summary != "" {
+			return summary
+		}
+	}
+	return ""
+}
+
+// generateShortText calls a model with a system prompt and user
+// input, returning a cleaned-up short text response. It reuses the
+// same retry logic as title generation.
+func generateShortText(
+	ctx context.Context,
+	model fantasy.LanguageModel,
+	systemPrompt string,
+	userInput string,
+) (string, error) {
+	prompt := []fantasy.Message{
+		{
+			Role: fantasy.MessageRoleSystem,
+			Content: []fantasy.MessagePart{
+				fantasy.TextPart{Text: systemPrompt},
+			},
+		},
+		{
+			Role: fantasy.MessageRoleUser,
+			Content: []fantasy.MessagePart{
+				fantasy.TextPart{Text: userInput},
+			},
+		},
+	}
+
+	var maxOutputTokens int64 = 256
+
+	var response *fantasy.Response
+	err := chatretry.Retry(ctx, func(retryCtx context.Context) error {
+		var genErr error
+		response, genErr = model.Generate(retryCtx, fantasy.Call{
+			Prompt:          prompt,
+			MaxOutputTokens: &maxOutputTokens,
+		})
+		return genErr
+	}, nil)
+	if err != nil {
+		return "", xerrors.Errorf("generate short text: %w", err)
+	}
+
+	text := strings.TrimSpace(contentBlocksToText(response.Content))
+	text = strings.Trim(text, "\"'`")
+	return text, nil
+}