Merge pull request #776 from innogames/chatgpt_tags

feat: openai: add hashtag support for model selection, reasoning control, and message history

Author: brainexe

command/custom_commmands/handle.go

@@ -17,7 +17,7 @@ func (c command) handle(ref msg.Ref, text string) bool {
 		return false
 	}
 
-	c.SendMessage(ref, fmt.Sprintf("executing command: `%s`", commands))
+	c.SendEphemeralMessage(ref, fmt.Sprintf("executing command: `%s`", commands))
 	for _, command := range strings.Split(commands, ";") {
 		message := client.HandleMessageWithDoneHandler(ref.WithText(command))
 		message.Wait()

command/custom_commmands/integration_test.go

@@ -87,7 +87,7 @@ func TestCustomCommands(t *testing.T) {
 		message.User = "user1"
 		message.Text = "alias 1"
 
-		mocks.AssertSlackMessage(slackClient, message, "executing command: `reply 1`")
+		mocks.AssertSlackEphemeralMessage(slackClient, message, "executing command: `reply 1`")
 
 		getMessages := mocks.WaitForQueuedMessages(t, 1)
 

command/openai/command.go

@@ -73,6 +73,9 @@ func (c *openaiCommand) newConversation(match matcher.Result, message msg.Messag
 }
 
 func (c *openaiCommand) startConversation(message msg.Ref, text string) bool {
+	// Parse hashtags and get cleaned text
+	cleanText, hashtagOptions := ParseHashtags(text)
+
 	messageHistory := make([]ChatMessage, 0)
 
 	if c.cfg.InitialSystemMessage != "" {
@@ -82,6 +85,28 @@ func (c *openaiCommand) startConversation(message msg.Ref, text string) bool {
 		})
 	}
 
+	// Handle #message-history hashtag
+	if hashtagOptions.MessageHistory > 0 {
+		channelMessages, err := c.getChannelHistory(message.GetChannel(), hashtagOptions.MessageHistory)
+		if err != nil {
+			c.ReplyError(message, fmt.Errorf("can't load channel history: %w", err))
+			return true
+		}
+
+		// Add channel history as context
+		messageHistory = append(messageHistory, ChatMessage{
+			Role:    roleSystem,
+			Content: fmt.Sprintf("Recent channel conversation history (last %d messages):", hashtagOptions.MessageHistory),
+		})
+
+		for _, channelMsg := range channelMessages {
+			messageHistory = append(messageHistory, ChatMessage{
+				Role:    roleUser,
+				Content: fmt.Sprintf("User <@%s> wrote: %s", channelMsg.User, channelMsg.Text),
+			})
+		}
+	}
+
 	var storageIdentifier string
 	if message.GetThread() != "" {
 		// "openai" was triggered within a existing thread. -> fetch the whole thread history as context
@@ -106,10 +131,10 @@ func (c *openaiCommand) startConversation(message msg.Ref, text string) bool {
 		if c.cfg.LogTexts {
 			log.Infof("openai thread context: %s", messageHistory)
 		}
-	} else if linkRe.MatchString(text) {
+	} else if linkRe.MatchString(cleanText) {
 		// a link to another thread was posted -> use this messages as context
-		link := linkRe.FindStringSubmatch(text)
-		text = linkRe.ReplaceAllString(text, "")
+		link := linkRe.FindStringSubmatch(cleanText)
+		cleanText = linkRe.ReplaceAllString(cleanText, "")
 
 		relatedMessage := msg.MessageRef{
 			Channel: link[2],
@@ -134,7 +159,7 @@ func (c *openaiCommand) startConversation(message msg.Ref, text string) bool {
 		storageIdentifier = getIdentifier(message.GetChannel(), message.GetTimestamp())
 	}
 
-	c.callAndStore(messageHistory, storageIdentifier, message, text)
+	c.callAndStore(messageHistory, storageIdentifier, message, cleanText, hashtagOptions)
 	return true
 }
 
@@ -145,6 +170,9 @@ func (c *openaiCommand) reply(message msg.Ref, text string) bool {
 		return false
 	}
 
+	// Parse hashtags from reply message
+	cleanText, hashtagOptions := ParseHashtags(text)
+
 	// Load the chat history from storage.
 	identifier := getIdentifier(message.GetChannel(), message.GetThread())
 
@@ -156,24 +184,40 @@ func (c *openaiCommand) reply(message msg.Ref, text string) bool {
 	}
 
 	// Call the API and send the last messages as history to give a proper context
-	c.callAndStore(messages, identifier, message, text)
+	c.callAndStore(messages, identifier, message, cleanText, hashtagOptions)
 
 	return true
 }
 
 // call the GPT-3 API, sends the response to the user, and stores the updated chat history.
-func (c *openaiCommand) callAndStore(messages []ChatMessage, storageIdentifier string, message msg.Ref, inputText string) {
+func (c *openaiCommand) callAndStore(messages []ChatMessage, storageIdentifier string, message msg.Ref, inputText string, options HashtagOptions) {
 	// Append the actual user input to the message list.
 	messages = append(messages, ChatMessage{
 		Role:    roleUser,
 		Content: inputText,
 	})
 
-	messages, inputTokens, truncatedMessages := truncateMessages(c.cfg.Model, messages)
+	// Create a custom config based on hashtag options
+	customCfg := c.cfg
+
+	// Apply model override if specified
+	if options.Model != "" {
+		customCfg.Model = options.Model
+	}
+
+	// Apply reasoning effort if specified
+	if options.ReasoningEffort == "none" {
+		// User explicitly requested no reasoning effort with #no-thinking
+		customCfg.ReasoningEffort = ""
+	} else if options.ReasoningEffort != "" {
+		customCfg.ReasoningEffort = options.ReasoningEffort
+	}
+
+	messages, inputTokens, truncatedMessages := truncateMessages(customCfg.Model, messages)
 	if truncatedMessages > 0 {
 		c.SendMessage(
 			message,
-			fmt.Sprintf("Note: The token length of %d exceeded! %d messages were not sent", getMaxTokensForModel(c.cfg.Model), truncatedMessages),
+			fmt.Sprintf("Note: The token length of %d exceeded! %d messages were not sent", getMaxTokensForModel(customCfg.Model), truncatedMessages),
 			slack.MsgOptionTS(message.GetTimestamp()),
 		)
 	}
@@ -186,7 +230,8 @@ func (c *openaiCommand) callAndStore(messages []ChatMessage, storageIdentifier s
 
 		startTime := time.Now()
 
-		response, err := CallChatGPT(c.cfg, messages, true)
+		// Use customCfg instead of c.cfg
+		response, err := CallChatGPT(customCfg, messages, true)
 		if err != nil {
 			c.ReplyError(message, fmt.Errorf("openai error: %w", err))
 			return
@@ -254,7 +299,16 @@ func (c *openaiCommand) callAndStore(messages []ChatMessage, storageIdentifier s
 		logFields := log.Fields{
 			"input_tokens":  inputTokens,
 			"output_tokens": outputTokens,
-			"model":         c.cfg.Model,
+			"model":         customCfg.Model,
+		}
+		if options.Model != "" {
+			logFields["model_override"] = options.Model
+		}
+		if options.ReasoningEffort != "" {
+			logFields["reasoning_effort"] = customCfg.ReasoningEffort
+		}
+		if options.MessageHistory > 0 {
+			logFields["message_history_count"] = options.MessageHistory
 		}
 		if c.cfg.LogTexts {
 			logFields["input_text"] = inputText
@@ -297,15 +351,49 @@ func (c *openaiCommand) GetTemplateFunction() template.FuncMap {
 	}
 }
 
+// getChannelHistory fetches the last N messages from a channel (excluding threads)
+func (c *openaiCommand) getChannelHistory(channel string, count int) ([]slack.Message, error) {
+	params := &slack.GetConversationHistoryParameters{
+		ChannelID: channel,
+		Limit:     count,
+	}
+
+	response, err := c.GetConversationHistory(params)
+	if err != nil {
+		return nil, err
+	}
+
+	// Filter out messages that are thread replies (have ThreadTimestamp set)
+	mainMessages := make([]slack.Message, 0)
+	for _, message := range response.Messages {
+		// Only include main channel messages, not thread replies
+		if message.ThreadTimestamp == "" || message.ThreadTimestamp == message.Timestamp {
+			mainMessages = append(mainMessages, message)
+		}
+	}
+
+	// Reverse to get chronological order (API returns newest first)
+	for i := range len(mainMessages) / 2 {
+		j := len(mainMessages) - i - 1
+		mainMessages[i], mainMessages[j] = mainMessages[j], mainMessages[i]
+	}
+
+	return mainMessages, nil
+}
+
 func (c *openaiCommand) GetHelp() []bot.Help {
 	return []bot.Help{
 		{
 			Command:     "openai <question>",
-			Description: "Starts a chatgpt/openai conversation in a new thread",
+			Description: "Starts a chatgpt/openai conversation in a new thread. Supports hashtags for advanced options: #model-<name> (e.g., #model-gpt-4o), #high-thinking/#medium-thinking/#low-thinking/#no-thinking for reasoning control, #message-history or #message-history-<N> to include recent channel messages as context",
 			Category:    category,
 			Examples: []string{
 				"openai whats 1+1?",
 				"chatgpt whats 1+1?",
+				"openai #model-gpt-4o explain quantum computing",
+				"chatgpt #high-thinking #model-o1 solve this complex problem",
+				"openai #message-history-20 what did we discuss about the deployment?",
+				"chatgpt #model-gpt-4 #low-thinking #message-history quick summary please",
 			},
 		},
 		{

command/openai/dalle.go

@@ -65,7 +65,7 @@ func (c *openaiCommand) sendImageInSlack(image DalleResponseImage, message msg.M
 		Reader:          resp.Body,
 		Channel:         message.Channel,
 		ThreadTimestamp: message.Timestamp,
-		InitialComment:  fmt.Sprintf("Dall-e prompt: %s", image.RevisedPrompt),
+		InitialComment:  "Dall-e prompt: " + image.RevisedPrompt,
 	})
 
 	c.SendBlockMessage(

command/openai/hashtag_parser.go

@@ -0,0 +1,66 @@
+package openai
+
+import (
+	"regexp"
+	"strconv"
+	"strings"
+)
+
+// HashtagOptions contains parsed hashtag options from user input
+type HashtagOptions struct {
+	ReasoningEffort string // "low", "medium", "high", or ""
+	Model           string // override model, empty means use config default
+	MessageHistory  int    // number of channel messages to include, 0 means disabled
+}
+
+// ParseHashtags extracts hashtag options from the input text and returns
+// the cleaned text (without hashtags) and the parsed options
+func ParseHashtags(text string) (cleanText string, options HashtagOptions) {
+	// Define hashtag patterns
+	// Pattern priorities (specific to general):
+	// 1. #message-history-<number>
+	// 2. #message-history
+	// 3. #model-<name>
+	// 4. #high-thinking, #medium-thinking, #low-thinking, #no-thinking
+
+	// Parse message-history with number: #message-history-20
+	messageHistoryWithCountRe := regexp.MustCompile(`#message-history-(\d+)`)
+	if matches := messageHistoryWithCountRe.FindStringSubmatch(text); len(matches) > 1 {
+		if count, err := strconv.Atoi(matches[1]); err == nil {
+			options.MessageHistory = count
+		}
+		text = messageHistoryWithCountRe.ReplaceAllString(text, "")
+	} else if strings.Contains(text, "#message-history") {
+		// Parse message-history without number (default to 10)
+		options.MessageHistory = 10
+		text = strings.ReplaceAll(text, "#message-history", "")
+	}
+
+	// Parse model: #model-gpt-4o
+	modelRe := regexp.MustCompile(`#model-([\w.-]+)`)
+	if matches := modelRe.FindStringSubmatch(text); len(matches) > 1 {
+		options.Model = matches[1]
+		text = modelRe.ReplaceAllString(text, "")
+	}
+
+	// Parse reasoning effort
+	switch {
+	case strings.Contains(text, "#high-thinking"):
+		options.ReasoningEffort = "high"
+		text = strings.ReplaceAll(text, "#high-thinking", "")
+	case strings.Contains(text, "#medium-thinking"):
+		options.ReasoningEffort = "medium"
+		text = strings.ReplaceAll(text, "#medium-thinking", "")
+	case strings.Contains(text, "#low-thinking"):
+		options.ReasoningEffort = "low"
+		text = strings.ReplaceAll(text, "#low-thinking", "")
+	case strings.Contains(text, "#no-thinking"):
+		options.ReasoningEffort = "none"
+		text = strings.ReplaceAll(text, "#no-thinking", "")
+	}
+
+	// Clean up extra whitespace
+	cleanText = strings.Join(strings.Fields(text), " ")
+
+	return cleanText, options
+}

command/openai/hashtag_parser_test.go

@@ -0,0 +1,80 @@
+package openai
+
+import (
+	"testing"
+)
+
+func TestParseHashtags(t *testing.T) {
+	tests := []struct {
+		name            string
+		input           string
+		expectedText    string
+		expectedModel   string
+		expectedReason  string
+		expectedHistory int
+	}{
+		{
+			name:          "No hashtags",
+			input:         "What is Go?",
+			expectedText:  "What is Go?",
+			expectedModel: "",
+		},
+		{
+			name:          "Model only",
+			input:         "#model-gpt-4o What is Go?",
+			expectedText:  "What is Go?",
+			expectedModel: "gpt-4o",
+		},
+		{
+			name:           "High thinking",
+			input:          "#high-thinking Explain quantum computing",
+			expectedText:   "Explain quantum computing",
+			expectedReason: "high",
+		},
+		{
+			name:            "Message history default",
+			input:           "#message-history What was discussed?",
+			expectedText:    "What was discussed?",
+			expectedHistory: 10,
+		},
+		{
+			name:            "Message history with count",
+			input:           "#message-history-25 Summarize the conversation",
+			expectedText:    "Summarize the conversation",
+			expectedHistory: 25,
+		},
+		{
+			name:            "Multiple hashtags",
+			input:           "#model-o1 #high-thinking #message-history-15 Complex question",
+			expectedText:    "Complex question",
+			expectedModel:   "o1",
+			expectedReason:  "high",
+			expectedHistory: 15,
+		},
+		{
+			name:           "No thinking",
+			input:          "#no-thinking Quick answer please",
+			expectedText:   "Quick answer please",
+			expectedReason: "none",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			cleanText, options := ParseHashtags(tt.input)
+
+			if cleanText != tt.expectedText {
+				t.Errorf("Expected text '%s', got '%s'", tt.expectedText, cleanText)
+			}
+			if options.Model != tt.expectedModel {
+				t.Errorf("Expected model '%s', got '%s'", tt.expectedModel, options.Model)
+			}
+			if options.ReasoningEffort != tt.expectedReason {
+				t.Errorf("Expected reasoning '%s', got '%s'", tt.expectedReason, options.ReasoningEffort)
+			}
+			if options.MessageHistory != tt.expectedHistory {
+				t.Errorf("Expected history %d, got %d", tt.expectedHistory, options.MessageHistory)
+			}
+		})
+	}
+}

mocks/testing.go

@@ -32,6 +32,14 @@ func AssertSlackMessage(slackClient *SlackClient, ref msg.Ref, text string, opti
 	slackClient.On("SendMessage", args...).Once().Return("")
 }
 
+// AssertSlackEphemeralMessage is a test helper to check for a given ephemeral slack message
+func AssertSlackEphemeralMessage(slackClient *SlackClient, ref msg.Ref, text string, option ...any) {
+	args := []any{ref, text}
+	args = append(args, option...)
+
+	slackClient.On("SendEphemeralMessage", args...).Once()
+}
+
 // AssertSlackMessageRegexp is a test helper to check for a given slack message based on a regular expression
 func AssertSlackMessageRegexp(slackClient *SlackClient, ref msg.Ref, pattern string) {
 	slackClient.On("SendMessage", ref, mock.MatchedBy(func(text string) bool {