fix: use correct slice index for Bedrock tool result coalescing

When system messages are present in the request body,
promoteAnthropicSystemMessagesToParam filters them out, producing a
shorter  slice. The coalescing loop was using body.Messages[i+1]
(the original unfiltered slice) instead of messages[i+1] (the filtered
slice), causing index misalignment that could read wrong messages or
panic with out-of-bounds access.

Additionally, tool_result messages have Role "user", so they entered
the MessageRoleUser branch and went through convertUserMessage() which
does NOT coalesce consecutive tool results. The coalescing logic in the
default branch was unreachable for this role. Moved the hasToolResult
check into the MessageRoleUser branch so consecutive tool_result
messages are properly coalesced.

Updated existing test to reflect the now-working coalescing behavior,
and added a regression test with system messages to verify index
alignment.

Signed-off-by: liuhy <liuhongyu@apache.org>

Author: Aias00

internal/translator/anthropic_awsbedrock.go

@@ -78,36 +78,33 @@ func (a *anthropicToAWSBedrockTranslator) RequestBody(_ []byte, body *anthropics
 		msg := &messages[i]
 		switch msg.Role {
 		case anthropicschema.MessageRoleUser:
-			bedrockMsg, convErr := a.convertUserMessage(msg)
-			if convErr != nil {
-				return nil, nil, convErr
-			}
-			bedrockReq.Messages = append(bedrockReq.Messages, bedrockMsg)
-			i++
-		case anthropicschema.MessageRoleAssistant:
-			bedrockMsg, convErr := a.convertAssistantMessage(msg)
-			if convErr != nil {
-				return nil, nil, convErr
-			}
-			bedrockReq.Messages = append(bedrockReq.Messages, bedrockMsg)
-			i++
-		default:
-			// Check for tool_result content blocks (these come as "user" role in Anthropic
-			// but we handle them specially).
 			if hasToolResult(msg) {
 				bedrockMsg := a.convertToolResultMessage(msg)
 				// Coalesce consecutive tool result messages.
-				for i+1 < msgLen && hasToolResult(&body.Messages[i+1]) {
-					nextMsg := &body.Messages[i+1]
+				for i+1 < msgLen && hasToolResult(&messages[i+1]) {
+					nextMsg := &messages[i+1]
 					nextBedrockMsg := a.convertToolResultMessage(nextMsg)
 					bedrockMsg.Content = append(bedrockMsg.Content, nextBedrockMsg.Content...)
 					i++
 				}
 				bedrockReq.Messages = append(bedrockReq.Messages, bedrockMsg)
 			} else {
-				return nil, nil, fmt.Errorf("%w: unexpected role: %s", internalapi.ErrInvalidRequestBody, msg.Role)
+				bedrockMsg, convErr := a.convertUserMessage(msg)
+				if convErr != nil {
+					return nil, nil, convErr
+				}
+				bedrockReq.Messages = append(bedrockReq.Messages, bedrockMsg)
 			}
 			i++
+		case anthropicschema.MessageRoleAssistant:
+			bedrockMsg, convErr := a.convertAssistantMessage(msg)
+			if convErr != nil {
+				return nil, nil, convErr
+			}
+			bedrockReq.Messages = append(bedrockReq.Messages, bedrockMsg)
+			i++
+		default:
+			return nil, nil, fmt.Errorf("%w: unexpected role: %s", internalapi.ErrInvalidRequestBody, msg.Role)
 		}
 	}
 

internal/translator/anthropic_awsbedrock_test.go

@@ -1032,35 +1032,155 @@ func TestAnthropicToAWSBedrockTranslator_RequestBody_ToolResultMessages(t *testi
 	err = json.Unmarshal(body, &bedrockReq)
 	require.NoError(t, err)
 
-	// Should be: user, assistant, user (tool result 1), user (tool result 2).
-	// Tool result messages with role "user" go through convertUserMessage individually.
-	require.Len(t, bedrockReq.Messages, 4)
-
-	// First tool result message.
-	toolResultMsg1 := bedrockReq.Messages[2]
-	assert.Equal(t, awsbedrock.ConversationRoleUser, toolResultMsg1.Role)
-	require.Len(t, toolResultMsg1.Content, 1)
-	require.NotNil(t, toolResultMsg1.Content[0].ToolResult)
-	assert.Equal(t, "tu_abc", *toolResultMsg1.Content[0].ToolResult.ToolUseID)
-	require.Len(t, toolResultMsg1.Content[0].ToolResult.Content, 1)
-	assert.Equal(t, "72°F and sunny", *toolResultMsg1.Content[0].ToolResult.Content[0].Text)
-
-	// Second tool result message (error).
-	toolResultMsg2 := bedrockReq.Messages[3]
-	assert.Equal(t, awsbedrock.ConversationRoleUser, toolResultMsg2.Role)
-	require.Len(t, toolResultMsg2.Content, 1)
-	require.NotNil(t, toolResultMsg2.Content[0].ToolResult)
-	assert.Equal(t, "tu_def", *toolResultMsg2.Content[0].ToolResult.ToolUseID)
-	assert.Equal(t, "error", *toolResultMsg2.Content[0].ToolResult.Status)
-	require.Len(t, toolResultMsg2.Content[0].ToolResult.Content, 1)
-	assert.Equal(t, "Error: city not found", *toolResultMsg2.Content[0].ToolResult.Content[0].Text)
+	// Should be: user, assistant, user (coalesced tool results).
+	// Consecutive tool_result messages are coalesced into a single Bedrock message.
+	require.Len(t, bedrockReq.Messages, 3)
+
+	// Coalesced tool result message contains both tool results.
+	toolResultMsg := bedrockReq.Messages[2]
+	assert.Equal(t, awsbedrock.ConversationRoleUser, toolResultMsg.Role)
+	require.Len(t, toolResultMsg.Content, 2)
+
+	// First tool result.
+	require.NotNil(t, toolResultMsg.Content[0].ToolResult)
+	assert.Equal(t, "tu_abc", *toolResultMsg.Content[0].ToolResult.ToolUseID)
+	require.Len(t, toolResultMsg.Content[0].ToolResult.Content, 1)
+	assert.Equal(t, "72°F and sunny", *toolResultMsg.Content[0].ToolResult.Content[0].Text)
+
+	// Second tool result (error) coalesced into the same message.
+	require.NotNil(t, toolResultMsg.Content[1].ToolResult)
+	assert.Equal(t, "tu_def", *toolResultMsg.Content[1].ToolResult.ToolUseID)
+	assert.Equal(t, "error", *toolResultMsg.Content[1].ToolResult.Status)
+	require.Len(t, toolResultMsg.Content[1].ToolResult.Content, 1)
+	assert.Equal(t, "Error: city not found", *toolResultMsg.Content[1].ToolResult.Content[0].Text)
 
 	// Verify tool choice "any".
 	require.NotNil(t, bedrockReq.ToolConfig)
 	require.NotNil(t, bedrockReq.ToolConfig.ToolChoice)
 	assert.NotNil(t, bedrockReq.ToolConfig.ToolChoice.Any)
 }
 
+func TestAnthropicToAWSBedrockTranslator_RequestBody_ToolResultMessagesWithSystemMessages(t *testing.T) {
+	// Regression test: when system messages are present in the messages array,
+	// promoteAnthropicSystemMessagesToParam filters them out, creating a shorter
+	// `messages` slice. The coalescing loop must use the filtered `messages` slice
+	// (not body.Messages) to avoid index misalignment and potential out-of-bounds access.
+	translator := NewAnthropicToAWSBedrockTranslator("")
+	req := &anthropicschema.MessagesRequest{
+		Model:     "test-model",
+		MaxTokens: 100,
+		Tools: []anthropicschema.ToolUnion{
+			{Tool: &anthropicschema.Tool{
+				Type:        "custom",
+				Name:        "get_weather",
+				Description: "Get weather",
+				InputSchema: anthropicschema.ToolInputSchema{Type: "object"},
+			}},
+		},
+		Messages: []anthropicschema.MessageParam{
+			// System message at the start — will be promoted out of the messages slice.
+			{
+				Role:    "system",
+				Content: anthropicschema.MessageContent{Text: "You are a helpful assistant."},
+			},
+			// Another system message — also promoted.
+			{
+				Role:    "system",
+				Content: anthropicschema.MessageContent{Text: "Always be concise."},
+			},
+			{
+				Role:    anthropicschema.MessageRoleUser,
+				Content: anthropicschema.MessageContent{Text: "What's the weather?"},
+			},
+			{
+				Role: anthropicschema.MessageRoleAssistant,
+				Content: anthropicschema.MessageContent{
+					Array: []anthropicschema.ContentBlockParam{
+						{ToolUse: &anthropicschema.ToolUseBlockParam{
+							Type:  "tool_use",
+							ID:    "tu_abc",
+							Name:  "get_weather",
+							Input: map[string]any{"city": "NYC"},
+						}},
+					},
+				},
+			},
+			// First tool result message.
+			{
+				Role: anthropicschema.MessageRoleUser,
+				Content: anthropicschema.MessageContent{
+					Array: []anthropicschema.ContentBlockParam{
+						{ToolResult: &anthropicschema.ToolResultBlockParam{
+							Type:      "tool_result",
+							ToolUseID: "tu_abc",
+							Content:   &anthropicschema.ToolResultContent{Text: "72°F and sunny"},
+						}},
+					},
+				},
+			},
+			// Second consecutive tool result message (should be coalesced with the first).
+			{
+				Role: anthropicschema.MessageRoleUser,
+				Content: anthropicschema.MessageContent{
+					Array: []anthropicschema.ContentBlockParam{
+						{ToolResult: &anthropicschema.ToolResultBlockParam{
+							Type:      "tool_result",
+							ToolUseID: "tu_def",
+							IsError:   true,
+							Content: &anthropicschema.ToolResultContent{
+								Array: []anthropicschema.ToolResultContentItem{
+									{Text: &anthropicschema.TextBlockParam{Type: "text", Text: "Error: city not found"}},
+								},
+							},
+						}},
+					},
+				},
+			},
+		},
+	}
+	rawBody, err := json.Marshal(req)
+	require.NoError(t, err)
+
+	_, body, err := translator.RequestBody(rawBody, req, false)
+	require.NoError(t, err)
+
+	var bedrockReq awsbedrock.ConverseInput
+	err = json.Unmarshal(body, &bedrockReq)
+	require.NoError(t, err)
+
+	// After promoting 2 system messages, messages has 4 entries:
+	//   user, assistant, user(tool_result), user(tool_result)
+	// The two consecutive tool_result messages should be coalesced into one,
+	// yielding 3 Bedrock messages: user, assistant, user(coalesced tool results).
+	require.Len(t, bedrockReq.Messages, 3)
+
+	// First message: user text.
+	assert.Equal(t, awsbedrock.ConversationRoleUser, bedrockReq.Messages[0].Role)
+	require.Len(t, bedrockReq.Messages[0].Content, 1)
+	assert.NotNil(t, bedrockReq.Messages[0].Content[0].Text)
+
+	// Second message: assistant tool_use.
+	assert.Equal(t, awsbedrock.ConversationRoleAssistant, bedrockReq.Messages[1].Role)
+
+	// Third message: coalesced tool results (both tool_use_ids in one message).
+	toolResultMsg := bedrockReq.Messages[2]
+	assert.Equal(t, awsbedrock.ConversationRoleUser, toolResultMsg.Role)
+	require.Len(t, toolResultMsg.Content, 2)
+	require.NotNil(t, toolResultMsg.Content[0].ToolResult)
+	assert.Equal(t, "tu_abc", *toolResultMsg.Content[0].ToolResult.ToolUseID)
+	assert.Equal(t, "72°F and sunny", *toolResultMsg.Content[0].ToolResult.Content[0].Text)
+	require.NotNil(t, toolResultMsg.Content[1].ToolResult)
+	assert.Equal(t, "tu_def", *toolResultMsg.Content[1].ToolResult.ToolUseID)
+	assert.Equal(t, "error", *toolResultMsg.Content[1].ToolResult.Status)
+	assert.Equal(t, "Error: city not found", *toolResultMsg.Content[1].ToolResult.Content[0].Text)
+
+	// Verify system prompt was promoted.
+	require.NotNil(t, bedrockReq.System)
+	require.Len(t, bedrockReq.System, 1)
+	assert.Contains(t, *bedrockReq.System[0].Text, "You are a helpful assistant.")
+	assert.Contains(t, *bedrockReq.System[0].Text, "Always be concise.")
+}
+
 func TestAnthropicToAWSBedrockTranslator_ResponseBody_NonStreamingToolUseAndReasoning(t *testing.T) {
 	translator := NewAnthropicToAWSBedrockTranslator("")
 	req := &anthropicschema.MessagesRequest{