Merge pull request #165 from flocko-motion/flo-dev

AI optimizations

Author: flocko-motion

server/functional/strings.go

@@ -116,6 +116,64 @@ func EnsurePointer(o any) any {
 	return ptr.Interface()
 }
 
+// EndsWithDigits checks if a dash-separated string ends with a segment of exactly n digits.
+// Useful for filtering dated/versioned model IDs like "gpt-4-0613" or "mistral-small-2402".
+func EndsWithDigits(s string, n int) bool {
+	parts := SplitDash(s)
+	if len(parts) < 2 {
+		return false
+	}
+	last := parts[len(parts)-1]
+	if len(last) != n {
+		return false
+	}
+	for _, ch := range last {
+		if ch < '0' || ch > '9' {
+			return false
+		}
+	}
+	return true
+}
+
+// EndsWithDatePattern checks if a dash-separated string ends with a YYYY-MM-DD pattern.
+// Example: "gpt-4-2024-01-25" returns true.
+func EndsWithDatePattern(s string) bool {
+	parts := SplitDash(s)
+	if len(parts) < 4 {
+		return false
+	}
+	lastThree := parts[len(parts)-3:]
+	if len(lastThree[0]) != 4 || len(lastThree[1]) != 2 || len(lastThree[2]) != 2 {
+		return false
+	}
+	for _, part := range lastThree {
+		for _, ch := range part {
+			if ch < '0' || ch > '9' {
+				return false
+			}
+		}
+	}
+	return true
+}
+
+// SplitDash splits a string by dashes. Convenience wrapper for model ID parsing.
+func SplitDash(s string) []string {
+	return splitBy(s, '-')
+}
+
+func splitBy(s string, sep byte) []string {
+	var parts []string
+	start := 0
+	for i := 0; i < len(s); i++ {
+		if s[i] == sep {
+			parts = append(parts, s[start:i])
+			start = i + 1
+		}
+	}
+	parts = append(parts, s[start:])
+	return parts
+}
+
 // NormalizeYaml unmarshals YAML into the given struct type and re-marshals it to normalize the format.
 // If o is not a pointer, a pointer to a new instance of its type is created automatically.
 func NormalizeYaml(in string, o any) string {

server/game/ai/mistral/mistral.go

@@ -195,28 +195,6 @@ func (p *MistralPlatform) ListModels(ctx context.Context, apiKey string) ([]obj.
 	return models, nil
 }
 
-// endsWithFourDigits checks if a model ID ends with -XXXX pattern (4 digits)
-func endsWithFourDigits(modelID string) bool {
-	parts := strings.Split(modelID, "-")
-	if len(parts) < 2 {
-		return false
-	}
-
-	lastPart := parts[len(parts)-1]
-
-	// Check if last part is exactly 4 digits
-	if len(lastPart) == 4 {
-		for _, ch := range lastPart {
-			if ch < '0' || ch > '9' {
-				return false
-			}
-		}
-		return true
-	}
-
-	return false
-}
-
 // isRelevantModel checks if a model supports chat completions
 func isRelevantModel(modelID string) bool {
 	// List of known non-chat model prefixes to skip
@@ -229,13 +207,13 @@ func isRelevantModel(modelID string) bool {
 	}
 
 	for _, prefix := range nonChatPrefixes {
-		if len(modelID) > len(prefix) && modelID[:len(prefix)] == prefix {
+		if strings.HasPrefix(modelID, prefix) {
 			return false
 		}
 	}
 
 	// Skip dated models (ending with -XXXX where X is a digit)
-	if endsWithFourDigits(modelID) {
+	if functional.EndsWithDigits(modelID, 4) {
 		return false
 	}
 

server/game/ai/openai/openai.go

@@ -66,16 +66,23 @@ type ModelSession struct {
 	ResponseID string `json:"responseId"`
 }
 
+// InputMessage represents a single message in the Responses API input array.
+// Role can be "developer" (instructions/reminders) or "user" (player actions).
+type InputMessage struct {
+	Role    string `json:"role"`
+	Content string `json:"content"`
+}
+
 // ResponsesAPIRequest is the request body for the Responses API
 type ResponsesAPIRequest struct {
-	Model              string      `json:"model"`
-	Input              string      `json:"input"`
-	Instructions       string      `json:"instructions,omitempty"`
-	PreviousResponseID string      `json:"previous_response_id,omitempty"`
-	Store              bool        `json:"store"`
-	Stream             bool        `json:"stream,omitempty"`
-	MaxOutputTokens    int         `json:"max_output_tokens,omitempty"`
-	Text               *TextConfig `json:"text,omitempty"`
+	Model              string         `json:"model"`
+	Input              []InputMessage `json:"input"`
+	Instructions       string         `json:"instructions,omitempty"`
+	PreviousResponseID string         `json:"previous_response_id,omitempty"`
+	Store              bool           `json:"store"`
+	Stream             bool           `json:"stream,omitempty"`
+	MaxOutputTokens    int            `json:"max_output_tokens,omitempty"`
+	Text               *TextConfig    `json:"text,omitempty"`
 }
 
 type TextConfig struct {
@@ -193,10 +200,10 @@ func (p *OpenAiPlatform) ExecuteAction(ctx context.Context, session *obj.GameSes
 	// Serialize the player action as JSON input (minimal AI-facing structure)
 	actionInput := action.ToAiJSON()
 
-	// Build the request
+	// Build the request (Input is set below based on action type)
 	req := ResponsesAPIRequest{
 		Model:           model,
-		Input:           actionInput,
+		Input:           []InputMessage{{Role: "user", Content: actionInput}},
 		Store:           true,
 		MaxOutputTokens: 5000,
 		Text: &TextConfig{
@@ -212,9 +219,17 @@ func (p *OpenAiPlatform) ExecuteAction(ctx context.Context, session *obj.GameSes
 	// System messages become instructions, otherwise use previous_response_id for continuity
 	if action.Type == obj.GameSessionMessageTypeSystem {
 		req.Instructions = action.Message
-		req.Input = templates.PromptMessageStart
+		req.Input = []InputMessage{{Role: "developer", Content: templates.PromptMessageStart}}
 	} else if modelSession.ResponseID != "" {
 		req.PreviousResponseID = modelSession.ResponseID
+		// Inject developer reminder with every player action to reinforce brevity
+		req.Input = []InputMessage{
+			{Role: "developer", Content: templates.ReminderExecuteAction},
+			{Role: "user", Content: actionInput},
+		}
+		// Set debug prompt showing full input sent to the AI
+		response.PromptStatusUpdate = functional.Ptr(
+			"[developer] " + templates.ReminderExecuteAction + "\n\n[user] " + actionInput)
 	}
 
 	responseStream := stream.Get().Lookup(response.ID)
@@ -273,21 +288,13 @@ func (p *OpenAiPlatform) ExecuteAction(ctx context.Context, session *obj.GameSes
 
 	response.ResponseRaw = &responseText
 
-	// Parse the AI response (uses flat status map) and convert to internal format
-	log.Debug("parsing OpenAI response", "response_length", len(responseText), "response_text", responseText)
-	var aiResp obj.GameSessionMessageAi
-	if err := json.Unmarshal([]byte(responseText), &aiResp); err != nil {
+	// Parse the AI response and convert to internal format
+	log.Debug("parsing AI response", "response_length", len(responseText), "response_text", responseText)
+	if err := status.ParseGameResponse(responseText, session.StatusFields, action.StatusFields, response); err != nil {
 		log.Error("failed to parse game response", "error", err, "response_text", responseText)
-		return usage, fmt.Errorf("failed to parse game response: %w", err)
+		return usage, err
 	}
 
-	// Convert flat status map back to ordered []StatusField using session's field definitions.
-	// Pass action's current status as fallback in case the AI omits a field.
-	fieldNames := status.FieldNames(session.StatusFields)
-	response.Message = aiResp.Message
-	response.StatusFields = status.MapToFields(aiResp.Status, fieldNames, status.FieldsToMap(action.StatusFields))
-	response.ImagePrompt = aiResp.ImagePrompt
-
 	// Update model session with new response ID
 	modelSession.ResponseID = apiResponse.ID
 	response.URLAnalytics = functional.Ptr("https://platform.openai.com/logs/" + apiResponse.ID)
@@ -348,10 +355,13 @@ func (p *OpenAiPlatform) ExpandStory(ctx context.Context, session *obj.GameSessi
 	}
 
 	// Build streaming request - plain text, no JSON schema
+	// Use developer role for the narration instruction (it's a directive, not player input)
 	model := p.ResolveModel(session.AiModel)
 	req := ResponsesAPIRequest{
-		Model:              model,
-		Input:              templates.PromptNarratePlotOutline,
+		Model: model,
+		Input: []InputMessage{
+			{Role: "developer", Content: templates.PromptNarratePlotOutline},
+		},
 		Store:              true,
 		Stream:             true,
 		MaxOutputTokens:    5000,
@@ -509,9 +519,9 @@ func callImageGenerationAPI(ctx context.Context, apiKey string, prompt string, s
 
 	// Note: style parameter is only supported for dall-e-3, not gpt-image-1
 	// For gpt-image-1, we include the style in the prompt instead
-	fullPrompt := prompt
+	fullPrompt := prompt + templates.ImagePromptSuffix
 	if style != "" {
-		fullPrompt = fmt.Sprintf("%s. Style: %s", prompt, style)
+		fullPrompt = fmt.Sprintf("%s Style: %s", fullPrompt, style)
 	}
 
 	reqBody := map[string]interface{}{
@@ -608,7 +618,7 @@ func (p *OpenAiPlatform) Translate(ctx context.Context, apiKey string, input []s
 	req := ResponsesAPIRequest{
 		Model:        translateModel,
 		Instructions: lang.TranslateInstruction,
-		Input:        fmt.Sprintf("Translate this JSON to %s:\n\n%s", lang.GetLanguageName(targetLang), originals),
+		Input:        []InputMessage{{Role: "user", Content: fmt.Sprintf("Translate this JSON to %s:\n\n%s", lang.GetLanguageName(targetLang), originals)}},
 		Store:        false,
 		Text: &TextConfig{
 			Format: FormatConfig{
@@ -729,45 +739,7 @@ func isIrrelevantModel(modelID string) bool {
 
 // isDatedModel checks if a model ID ends with a date or version pattern
 func isDatedModel(modelID string) bool {
-	parts := strings.Split(modelID, "-")
-	if len(parts) < 2 {
-		return false
-	}
-
-	lastPart := parts[len(parts)-1]
-
-	// Check if ends with 4 digits (e.g., -1106, -0914)
-	if len(lastPart) == 4 {
-		for _, ch := range lastPart {
-			if ch < '0' || ch > '9' {
-				return false
-			}
-		}
-		return true
-	}
-
-	// Check if model ends with -YYYY-MM-DD pattern
-	if len(parts) < 3 {
-		return false
-	}
-
-	// Get last 3 parts
-	lastThree := parts[len(parts)-3:]
-
-	// Check if they match YYYY-MM-DD pattern
-	if len(lastThree[0]) == 4 && len(lastThree[1]) == 2 && len(lastThree[2]) == 2 {
-		// Verify they're all numeric
-		for _, part := range lastThree {
-			for _, ch := range part {
-				if ch < '0' || ch > '9' {
-					return false
-				}
-			}
-		}
-		return true
-	}
-
-	return false
+	return functional.EndsWithDigits(modelID, 4) || functional.EndsWithDatePattern(modelID)
 }
 
 // GenerateTheme generates a visual theme JSON for the game player UI
@@ -785,7 +757,7 @@ func (p *OpenAiPlatform) GenerateTheme(ctx context.Context, session *obj.GameSes
 	reqBody := ResponsesAPIRequest{
 		Model:        model,
 		Instructions: systemPrompt,
-		Input:        userPrompt,
+		Input:        []InputMessage{{Role: "user", Content: userPrompt}},
 		Store:        false, // Don't store theme generation in conversation history
 	}
 

server/game/game_logic.go

@@ -415,7 +415,10 @@ func DoSessionAction(ctx context.Context, session *obj.GameSession, action obj.G
 	}
 	response.TokenUsage = &usage
 	// Set prompts on response for transparency (educational debug view)
-	response.PromptStatusUpdate = functional.Ptr(action.ToAiJSON())
+	// PromptStatusUpdate is set by the platform's ExecuteAction (platform-specific input format)
+	if response.PromptStatusUpdate == nil {
+		response.PromptStatusUpdate = functional.Ptr(action.ToAiJSON())
+	}
 	response.PromptResponseSchema = functional.Ptr(string(gameSchemaJSON))
 	response.PromptExpandStory = functional.Ptr(templates.PromptNarratePlotOutline)
 	response.PromptImageGeneration = response.ImagePrompt

server/game/status/parse.go

@@ -0,0 +1,25 @@
+package status
+
+import (
+	"cgl/obj"
+	"encoding/json"
+	"fmt"
+)
+
+// ParseGameResponse parses raw AI JSON text into the response message fields.
+// It unmarshals the AI response, converts the flat status map back to ordered
+// []StatusField, and populates response.Message, StatusFields, and ImagePrompt.
+// actionStatusFields provides fallback values if the AI omits a field.
+func ParseGameResponse(responseText string, sessionStatusFields string, actionStatusFields []obj.StatusField, response *obj.GameSessionMessage) error {
+	var aiResp obj.GameSessionMessageAi
+	if err := json.Unmarshal([]byte(responseText), &aiResp); err != nil {
+		return fmt.Errorf("failed to parse game response: %w", err)
+	}
+
+	fieldNames := FieldNames(sessionStatusFields)
+	response.Message = aiResp.Message
+	response.StatusFields = MapToFields(aiResp.Status, fieldNames, FieldsToMap(actionStatusFields))
+	response.ImagePrompt = aiResp.ImagePrompt
+
+	return nil
+}

server/game/status/status.go

@@ -55,15 +55,16 @@ func BuildResponseSchema(statusFieldsJSON string) map[string]interface{} {
 	// Build status properties with exact field names as keys
 	statusProperties := make(map[string]interface{}, len(fieldNames))
 	for _, name := range fieldNames {
-		statusProperties[name] = map[string]interface{}{"type": "string"}
+		statusProperties[name] = map[string]interface{}{"type": "string", "maxLength": 30}
 	}
 
 	return map[string]interface{}{
 		"type": "object",
 		"properties": map[string]interface{}{
 			"message": map[string]interface{}{
 				"type":        "string",
-				"description": "The narrative response to the player's action",
+				"maxLength":   400,
+				"description": "Telegram-style. Subject-verb-object. No adjectives. Example: 'You start reciting. Dog interrupts. Courtiers laugh.'",
 			},
 			"status": map[string]interface{}{
 				"type":                 "object",
@@ -74,7 +75,8 @@ func BuildResponseSchema(statusFieldsJSON string) map[string]interface{} {
 			},
 			"imagePrompt": map[string]interface{}{
 				"type":        "string",
-				"description": "Description for generating an image of the scene",
+				"maxLength":   150,
+				"description": "Short visual description of the scene for image generation",
 			},
 		},
 		"required":             []string{"message", "status", "imagePrompt"},

server/game/templates/templates.go

@@ -19,6 +19,13 @@ const (
 	PromptMessageStart = "Start the game. Generate the opening scene. Set the status fields to good initial values for the scenario."
 	// PromptNarratePlotOutline is sent after each JSON response to get prose narration
 	PromptNarratePlotOutline = "NARRATE the summary into prose. STRICT RULES: 1-3 sentences MAXIMUM. No headers, no markdown, no lists. Do NOT repeat status fields. End on an open note. Be brief and atmospheric."
+
+	// ReminderExecuteAction is injected as a developer message with every player action
+	// to reinforce brevity constraints that the model tends to forget over long conversations.
+	ReminderExecuteAction = "STRICT OUTPUT RULES: message=telegraph-style (subject-verb-object, no adjectives, max 2 sentences). status=short labels (1-3 words each, e.g. 'Low', 'Newcomer'). imagePrompt=max 6 words, visual only."
+
+	// ImagePromptSuffix is appended to every image generation prompt to avoid inconsistent player depictions.
+	ImagePromptSuffix = ". Do not depict the player character."
 )
 
 func ImageStyleOrDefault(style string) string {
@@ -101,9 +108,9 @@ func GetTemplate(game *obj.Game) (string, error) {
 
 	actionOutput := obj.GameSessionMessageAi{
 		Type:        obj.GameSessionMessageTypeGame,
-		Message:     "You drink the potion. You feel a little bit dizzy. You feel a little bit stronger.",
+		Message:     "Player drinks potion, feels dizzy then stronger.",
 		Status:      statusMap,
-		ImagePrompt: functional.Ptr("a castle in the background, green grass, late afternoon"),
+		ImagePrompt: functional.Ptr("green grass, late afternoon, castle in background"),
 	}
 	actionOutputStr, _ := json.Marshal(actionOutput)