main -> v1.5.0 backmerge

core/changelog.md

@@ -0,0 +1,2 @@
+- fix: case-insensitive `anthropic-beta` merge in `MergeBetaHeaders`
+- fix: Bedrock provider - emit message_stop event for Anthropic invoke stream [@tefimov](https://github.com/tefimov)

core/providers/bedrock/bedrock_test.go

@@ -15,7 +15,10 @@ import (
 )
 
 func mustMarshalJSON(v interface{}) json.RawMessage {
-	b, _ := json.Marshal(v)
+	b, err := json.Marshal(v)
+	if err != nil {
+		panic("mustMarshalJSON: " + err.Error())
+	}
 	return json.RawMessage(b)
 }
 
@@ -40,7 +43,10 @@ func jsonEqual(t *testing.T, expected, actual json.RawMessage, msgAndArgs ...int
 // mustMarshalToolParams marshals ToolFunctionParameters to json.RawMessage,
 // matching the conversion code path for deterministic output.
 func mustMarshalToolParams(params *schemas.ToolFunctionParameters) json.RawMessage {
-	b, _ := json.Marshal(params)
+	b, err := json.Marshal(params)
+	if err != nil {
+		panic("mustMarshalToolParams: " + err.Error())
+	}
 	return json.RawMessage(b)
 }
 
@@ -3663,3 +3669,114 @@ func TestToBedrockInvokeMessagesStreamResponse_NoDuplicateContentBlockStop(t *te
 
 	assert.Equal(t, 1, stopCount, "expected exactly one content_block_stop event, got %d", stopCount)
 }
+
+func TestToolResultImageContentResponsesAPI(t *testing.T) {
+	// Minimal 1x1 red PNG
+	pngBase64 := "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAIAAACQd1PeAAAADElEQVR4nGP4z8AAAAMBAQDJ/pLvAAAAAElFTkSuQmCC"
+
+	t.Run("ImageBlockPreservedInToolResult", func(t *testing.T) {
+		input := []schemas.ResponsesMessage{
+			{
+				Type: schemas.Ptr(schemas.ResponsesMessageTypeFunctionCallOutput),
+				ResponsesToolMessage: &schemas.ResponsesToolMessage{
+					CallID: schemas.Ptr("tooluse_screenshot_001"),
+					Output: &schemas.ResponsesToolMessageOutputStruct{
+						ResponsesFunctionToolCallOutputBlocks: []schemas.ResponsesMessageContentBlock{
+							{
+								Type: schemas.ResponsesInputMessageContentBlockTypeImage,
+								ResponsesInputMessageContentBlockImage: &schemas.ResponsesInputMessageContentBlockImage{
+									ImageURL: schemas.Ptr("data:image/png;base64," + pngBase64),
+								},
+							},
+						},
+					},
+				},
+			},
+		}
+
+		messages, _, err := bedrock.ConvertBifrostMessagesToBedrockMessages(input)
+		require.NoError(t, err)
+		require.Len(t, messages, 1)
+
+		toolResultMsg := messages[0]
+		assert.Equal(t, bedrock.BedrockMessageRoleUser, toolResultMsg.Role)
+		require.Len(t, toolResultMsg.Content, 1)
+
+		toolResult := toolResultMsg.Content[0].ToolResult
+		require.NotNil(t, toolResult, "expected tool result in content block")
+		assert.Equal(t, "tooluse_screenshot_001", toolResult.ToolUseID)
+		require.Len(t, toolResult.Content, 1, "tool result should contain exactly one content block")
+
+		imageBlock := toolResult.Content[0]
+		require.NotNil(t, imageBlock.Image, "tool result content should be an image")
+		assert.Equal(t, "png", imageBlock.Image.Format)
+		require.NotNil(t, imageBlock.Image.Source.Bytes)
+		assert.Equal(t, pngBase64, *imageBlock.Image.Source.Bytes)
+	})
+
+	t.Run("MixedTextAndImageBlocksPreserved", func(t *testing.T) {
+		input := []schemas.ResponsesMessage{
+			{
+				Type: schemas.Ptr(schemas.ResponsesMessageTypeFunctionCallOutput),
+				ResponsesToolMessage: &schemas.ResponsesToolMessage{
+					CallID: schemas.Ptr("tooluse_mixed_002"),
+					Output: &schemas.ResponsesToolMessageOutputStruct{
+						ResponsesFunctionToolCallOutputBlocks: []schemas.ResponsesMessageContentBlock{
+							{
+								Type: schemas.ResponsesOutputMessageContentTypeText,
+								Text: schemas.Ptr("Screenshot captured successfully"),
+							},
+							{
+								Type: schemas.ResponsesInputMessageContentBlockTypeImage,
+								ResponsesInputMessageContentBlockImage: &schemas.ResponsesInputMessageContentBlockImage{
+									ImageURL: schemas.Ptr("data:image/png;base64," + pngBase64),
+								},
+							},
+						},
+					},
+				},
+			},
+		}
+
+		messages, _, err := bedrock.ConvertBifrostMessagesToBedrockMessages(input)
+		require.NoError(t, err)
+		require.Len(t, messages, 1)
+
+		toolResult := messages[0].Content[0].ToolResult
+		require.NotNil(t, toolResult)
+		require.Len(t, toolResult.Content, 2, "both text and image blocks should be preserved")
+
+		assert.NotNil(t, toolResult.Content[0].Text, "first block should be text")
+		assert.NotNil(t, toolResult.Content[1].Image, "second block should be image")
+		assert.Equal(t, "png", toolResult.Content[1].Image.Format)
+	})
+
+	t.Run("RemoteURLImageGracefullyDropped", func(t *testing.T) {
+		input := []schemas.ResponsesMessage{
+			{
+				Type: schemas.Ptr(schemas.ResponsesMessageTypeFunctionCallOutput),
+				ResponsesToolMessage: &schemas.ResponsesToolMessage{
+					CallID: schemas.Ptr("tooluse_remote_003"),
+					Output: &schemas.ResponsesToolMessageOutputStruct{
+						ResponsesFunctionToolCallOutputBlocks: []schemas.ResponsesMessageContentBlock{
+							{
+								Type: schemas.ResponsesInputMessageContentBlockTypeImage,
+								ResponsesInputMessageContentBlockImage: &schemas.ResponsesInputMessageContentBlockImage{
+									ImageURL: schemas.Ptr("https://example.com/screenshot.png"),
+								},
+							},
+						},
+					},
+				},
+			},
+		}
+
+		messages, _, err := bedrock.ConvertBifrostMessagesToBedrockMessages(input)
+		require.NoError(t, err)
+		require.Len(t, messages, 1)
+
+		toolResult := messages[0].Content[0].ToolResult
+		require.NotNil(t, toolResult)
+		assert.Empty(t, toolResult.Content, "remote URL image should be dropped (Bedrock only supports base64)")
+	})
+}

core/providers/bedrock/invoke.go

@@ -644,24 +644,27 @@ func ToBedrockInvokeMessagesStreamResponse(ctx *schemas.BifrostContext, resp *sc
 	}
 
 	// For Anthropic models (and default): serialize as Anthropic Messages API SSE events,
-	// then wrap in InvokeModelRawChunk
-	rawBytes, err := toAnthropicInvokeStreamBytes(resp)
+	// then wrap in InvokeModelRawChunks. Some Bifrost events map to multiple Anthropic events
+	// (e.g., Completed → message_delta + message_stop).
+	rawChunks, err := toAnthropicInvokeStreamBytes(resp)
 	if err != nil {
 		return "", nil, err
 	}
-	if rawBytes == nil {
+	if len(rawChunks) == 0 {
 		return "", nil, nil
 	}
 
 	bedrockEvent := &BedrockStreamEvent{
-		InvokeModelRawChunk: rawBytes,
+		InvokeModelRawChunks: rawChunks,
 	}
 	return "", bedrockEvent, nil
 }
 
 // toAnthropicInvokeStreamBytes converts a Bifrost stream event into raw bytes representing
-// the Anthropic Messages API streaming event JSON, suitable for wrapping in InvokeModelRawChunk.
-func toAnthropicInvokeStreamBytes(resp *schemas.BifrostResponsesStreamResponse) ([]byte, error) {
+// the Anthropic Messages API streaming event JSON, suitable for wrapping in InvokeModelRawChunks.
+// Returns a slice of byte slices since some Bifrost events map to multiple Anthropic events
+// (e.g., Completed → message_delta + message_stop).
+func toAnthropicInvokeStreamBytes(resp *schemas.BifrostResponsesStreamResponse) ([][]byte, error) {
 	var event interface{}
 
 	switch resp.Type {
@@ -830,13 +833,13 @@ func toAnthropicInvokeStreamBytes(resp *schemas.BifrostResponsesStreamResponse)
 		return nil, nil
 
 	case schemas.ResponsesStreamResponseTypeCompleted:
-		// Emit message_delta + message_stop
+		// Emit message_delta + message_stop as two separate events
 		stopReason := "end_turn"
 		if resp.Response != nil && resp.Response.IncompleteDetails != nil {
 			stopReason = resp.Response.IncompleteDetails.Reason
 		}
 
-		// Build combined payload: message_delta data
+		// Build message_delta event
 		messageDelta := map[string]interface{}{
 			"type": "message_delta",
 			"delta": map[string]interface{}{
@@ -849,7 +852,22 @@ func toAnthropicInvokeStreamBytes(resp *schemas.BifrostResponsesStreamResponse)
 				"output_tokens": resp.Response.Usage.OutputTokens,
 			}
 		}
-		event = messageDelta
+
+		// Build message_stop event
+		messageStop := map[string]interface{}{
+			"type": "message_stop",
+		}
+
+		// Marshal both events
+		deltaBytes, err := providerUtils.MarshalSorted(messageDelta)
+		if err != nil {
+			return nil, fmt.Errorf("failed to marshal message_delta event: %w", err)
+		}
+		stopBytes, err := providerUtils.MarshalSorted(messageStop)
+		if err != nil {
+			return nil, fmt.Errorf("failed to marshal message_stop event: %w", err)
+		}
+		return [][]byte{deltaBytes, stopBytes}, nil
 
 	default:
 		return nil, nil
@@ -859,9 +877,9 @@ func toAnthropicInvokeStreamBytes(resp *schemas.BifrostResponsesStreamResponse)
 		return nil, nil
 	}
 
-	bytes, err := providerUtils.MarshalSorted(event)
+	eventBytes, err := providerUtils.MarshalSorted(event)
 	if err != nil {
 		return nil, fmt.Errorf("failed to marshal invoke stream event: %w", err)
 	}
-	return bytes, nil
+	return [][]byte{eventBytes}, nil
 }

core/providers/bedrock/responses.go

@@ -1302,11 +1302,11 @@ type BedrockInvokeStreamChunkEvent struct {
 func (event *BedrockStreamEvent) ToEncodedEvents() []BedrockEncodedEvent {
 	var events []BedrockEncodedEvent
 
-	if event.InvokeModelRawChunk != nil {
+	for _, rawChunk := range event.InvokeModelRawChunks {
 		events = append(events, BedrockEncodedEvent{
 			EventType: "chunk",
 			Payload: BedrockInvokeStreamChunkEvent{
-				Bytes: event.InvokeModelRawChunk,
+				Bytes: rawChunk,
 			},
 		})
 	}
@@ -2565,6 +2565,18 @@ func ConvertBifrostMessagesToBedrockMessages(bifrostMessages []schemas.Responses
 						for _, block := range msg.ResponsesToolMessage.Output.ResponsesFunctionToolCallOutputBlocks {
 							if block.Text != nil {
 								resultContent = append(resultContent, tryParseJSONIntoContentBlock(*block.Text))
+							} else if block.Type == schemas.ResponsesInputMessageContentBlockTypeImage &&
+								block.ResponsesInputMessageContentBlockImage != nil &&
+								block.ResponsesInputMessageContentBlockImage.ImageURL != nil {
+								imageSource, err := convertImageToBedrockSource(*block.ResponsesInputMessageContentBlockImage.ImageURL)
+								if err != nil {
+									// Bedrock only supports base64 data URIs for images. If conversion
+									// fails (e.g. remote URL), the image is dropped from the tool result
+									// which silently degrades the model's ability to see tool output.
+									_ = fmt.Errorf("bedrock: converting tool result image: %w", err)
+								} else {
+									resultContent = append(resultContent, BedrockContentBlock{Image: imageSource})
+								}
 							}
 						}
 					}

core/providers/bedrock/types.go

@@ -603,7 +603,10 @@ type BedrockStreamEvent struct {
 	AdditionalModelResponseFields interface{} `json:"additionalModelResponseFields,omitempty"`
 
 	// For InvokeModelWithResponseStream (Legacy API)
-	InvokeModelRawChunk []byte `json:"invokeModelRawChunk,omitempty"` // Raw bytes for legacy invoke stream
+	// InvokeModelRawChunks holds one or more raw byte payloads for legacy invoke stream.
+	// Multiple chunks are needed when a single Bifrost event maps to multiple Anthropic SSE events
+	// (e.g., Completed → message_delta + message_stop).
+	InvokeModelRawChunks [][]byte `json:"invokeModelRawChunks,omitempty"`
 }
 
 // BedrockMessageStartEvent indicates the start of a message

docs/architecture/framework/model-catalog.mdx

@@ -321,7 +321,7 @@ You can reload the pricing configuration at runtime if you need to change the pr
 newConfig := &modelcatalog.Config{
     PricingSyncInterval: 12 * time.Hour,
 }
-err := modelCatalog.ReloadPricing(ctx, newConfig)
+err := modelCatalog.UpdateSyncConfig(ctx, newConfig)
 ```
 
 ## Error Handling and Fallbacks

docs/changelogs/v1.5.0-prerelease2.mdx

@@ -49,24 +49,8 @@ description: "v1.5.0-prerelease2 changelog - 2026-04-08"
 - **Data Race Fix** — Fix race in data reading from fasthttp request for integrations
 - **Model Listing** — Unify /api/models and /api/models/details listing behavior
 
-<Warning>
-**v1.5.0 contains multiple breaking changes.** See the [v1.5.0 Migration Guide](/migration-guides/v1.5.0) for full before/after examples and a migration checklist.
-</Warning>
-
-## Breaking Changes in This Release
-
-This prerelease introduces 3 additional breaking changes on top of those in prerelease1. See the **[v1.5.0 Migration Guide](/migration-guides/v1.5.0)** for full before/after examples, automatic migration details, and a step-by-step checklist.
-
-| # | Breaking Change | Affected |
-|---|---|---|
-| [9](/migration-guides/v1.5.0#breaking-change-9-provider-deployments-removed-migrate-to-aliases) | Provider `deployments` removed — migrate Azure, Bedrock, Vertex, and Replicate deployment maps to the unified top-level `aliases` field | `config.json`, REST API, Go SDK |
-| [10](/migration-guides/v1.5.0#breaking-change-10-go-sdk-extrafields-model-fields-renamed) | Go SDK: `ExtraFields.ModelRequested` replaced by `OriginalModelRequested` + `ResolvedModelUsed` | Go SDK |
-| [11](/migration-guides/v1.5.0#breaking-change-11-go-sdk-streamaccumulatorresult-field-renamed) | Go SDK: `StreamAccumulatorResult.Model` replaced by `RequestedModel` + `ResolvedModel` | Go SDK |
-
----
 </Update>
 <Update label="Core" description="1.5.1">
-- feat: add model alias support — map model names to provider-specific identifiers per key
 - feat: add Fireworks AI as a first-class provider (thanks [@ivanetchart](https://github.com/ivanetchart)!)
 - feat: add realtime provider interfaces, schemas, and engine hooks
 - feat: add session log storage and realtime request normalization
@@ -89,7 +73,6 @@ This prerelease introduces 3 additional breaking changes on top of those in prer
 
 </Update>
 <Update label="Framework" description="1.3.1">
-- feat: add model alias storage and encryption in key config
 - feat: add per-user OAuth consent flow with identity selection and MCP authentication
 - feat: add access profiles for fine-grained permission control
 - feat: add user level OAuth for MCP gateway