v1.5.16

.github/workflows/helm-release.yml

@@ -105,6 +105,7 @@ jobs:
           cd helm-charts
           gh release create "helm-chart-v${{ steps.chart-version.outputs.version }}" \
             bifrost-${{ steps.chart-version.outputs.version }}.tgz \
+            --target ${{ github.sha }} \
             --title "Helm Chart v${{ steps.chart-version.outputs.version }}" \
             --notes "Helm chart release for Bifrost v${{ steps.chart-version.outputs.version }}"
         env:

core/bifrost.go

@@ -514,9 +514,20 @@ func (bifrost *Bifrost) ListAllModels(ctx *schemas.BifrostContext, req *schemas.
 
 				response, bifrostErr := bifrost.ListModelsRequest(providerCtx, providerRequest)
 				if bifrostErr != nil {
-					// Skip logging "no keys found" and "not supported" errors as they are expected when a provider is not configured
-					if !strings.Contains(bifrostErr.Error.Message, "no keys found") &&
-						!strings.Contains(bifrostErr.Error.Message, "not supported") {
+					// Some per-provider failures are expected when fanning out across all
+					// configured providers and must not be surfaced as a top-level error
+					errType := ""
+					if bifrostErr.Type != nil {
+						errType = *bifrostErr.Type
+					}
+					errMsg := ""
+					if bifrostErr.Error != nil {
+						errMsg = bifrostErr.Error.Message
+					}
+					isExpected := strings.Contains(errMsg, "no keys found") ||
+						strings.Contains(errMsg, "not supported") ||
+						errType == "provider_blocked"
+					if !isExpected {
 						providerErr = bifrostErr
 						bifrost.logger.Warn("failed to list models for provider %s: %s", providerKey, bifrostErr.GetErrorString())
 					}

core/bifrost_test.go

@@ -711,7 +711,7 @@ func (ma *MockAccount) AddProviderWithBaseURL(provider schemas.ModelProvider, co
 	ma.configs[provider] = &schemas.ProviderConfig{
 		NetworkConfig: schemas.NetworkConfig{
 			BaseURL:                        baseURL,
-			DefaultRequestTimeoutInSeconds: 30,
+			DefaultRequestTimeoutInSeconds: 300,
 			MaxRetries:                     3,
 			RetryBackoffInitial:            500 * time.Millisecond,
 			RetryBackoffMax:                5 * time.Second,

core/internal/llmtests/passthrough_api.go

@@ -87,7 +87,7 @@ func buildPassthroughChatReq(t *testing.T, provider schemas.ModelProvider, model
 		return passthroughChatReq{path: "/v1/messages", body: body}, true
 
 	case schemas.Gemini:
-		nativeReq, err := gemini.ToGeminiChatCompletionRequest(bfReq)
+		nativeReq, err := gemini.ToGeminiChatCompletionRequest(ctx, bfReq)
 		if err != nil {
 			return passthroughChatReq{}, false
 		}

core/providers/anthropic/advisor_test.go

@@ -358,3 +358,105 @@ func TestAdvisorStream_RoundTrip(t *testing.T) {
 		t.Error("text block dropped")
 	}
 }
+
+// countPassthroughMessageStarts mirrors the transport passthrough converter
+// (transports/bifrost-http/integrations/anthropic.go): for each bifrost stream
+// response it forwards the raw upstream frame verbatim when present (except
+// ContentPartAdded), otherwise falls back to the normalized converter. Returns
+// how many message_start frames are emitted and the raw bytes of the forwarded one.
+func countPassthroughMessageStarts(ctx *schemas.BifrostContext, responses []*schemas.BifrostResponsesStreamResponse) (int, string) {
+	count := 0
+	forwarded := ""
+	for _, r := range responses {
+		if r.ExtraFields.RawResponse != nil && r.Type != schemas.ResponsesStreamResponseTypeContentPartAdded {
+			raw, _ := r.ExtraFields.RawResponse.(string)
+			if gjson.Get(raw, "type").String() == "message_start" {
+				count++
+				forwarded = raw
+			}
+			continue
+		}
+		for _, ev := range ToAnthropicResponsesStreamResponse(ctx, r) {
+			if ev.Type == AnthropicStreamEventTypeMessageStart {
+				count++
+			}
+		}
+	}
+	return count, forwarded
+}
+
+// TestResponsesStream_MessageStart_NoDuplicateOnPassthrough guards the fix for the
+// duplicate message_start emitted on the Anthropic passthrough responses_stream
+// path. A single upstream message_start expands inbound into [response.created,
+// response.in_progress]. The raw upstream frame must ride on response.created
+// (which maps back to message_start) so it is forwarded once with all upstream
+// fields intact; response.in_progress must carry no raw and convert to nil.
+// Attaching the raw to in_progress instead (the old "last chunk" rule) produced
+// two message_start frames: a lossy synthesized one from created plus the
+// raw-forwarded one from in_progress.
+func TestResponsesStream_MessageStart_NoDuplicateOnPassthrough(t *testing.T) {
+	ctx := schemas.NewBifrostContext(nil, time.Time{})
+
+	const rawMessageStart = `{"type":"message_start","message":{"id":"msg_01","type":"message","role":"assistant","model":"claude-opus-4-8","content":[],"stop_reason":null,"usage":{"input_tokens":3450,"output_tokens":4,"service_tier":"standard","inference_geo":"not_available"}}}`
+
+	var chunk AnthropicStreamEvent
+	if err := sonic.Unmarshal([]byte(rawMessageStart), &chunk); err != nil {
+		t.Fatalf("unmarshal message_start: %v", err)
+	}
+
+	state := acquireAnthropicResponsesStreamState()
+	defer releaseAnthropicResponsesStreamState(state)
+
+	responses, bErr, _ := chunk.ToBifrostResponsesStream(ctx, 0, state)
+	if bErr != nil {
+		t.Fatalf("ToBifrostResponsesStream error: %v", bErr)
+	}
+
+	// Inbound must expand the single message_start into [created, in_progress].
+	if len(responses) != 2 {
+		t.Fatalf("expected 2 bifrost responses (created, in_progress), got %d", len(responses))
+	}
+	createdIdx := -1
+	for i, r := range responses {
+		if r.Type == schemas.ResponsesStreamResponseTypeCreated {
+			createdIdx = i
+		}
+	}
+	if createdIdx == -1 {
+		t.Fatal("expected a response.created in the message_start expansion")
+	}
+	// The fix attaches the raw to response.created; the old rule attached it to the
+	// last response (in_progress). Confirm they differ so the cases below exercise it.
+	if createdIdx == len(responses)-1 {
+		t.Fatal("response.created is last; raw attachment would not exercise the fix")
+	}
+
+	t.Run("raw on created emits one full message_start", func(t *testing.T) {
+		for _, r := range responses {
+			r.ExtraFields.RawResponse = nil
+		}
+		responses[createdIdx].ExtraFields.RawResponse = rawMessageStart
+
+		count, forwarded := countPassthroughMessageStarts(ctx, responses)
+		if count != 1 {
+			t.Fatalf("expected exactly 1 message_start, got %d", count)
+		}
+		// The surviving frame must be the verbatim upstream bytes, preserving
+		// service_tier/inference_geo that the synthesized frame drops.
+		if forwarded != rawMessageStart {
+			t.Errorf("forwarded message_start is not the verbatim upstream frame: %s", forwarded)
+		}
+	})
+
+	t.Run("raw on in_progress (old behavior) duplicates message_start", func(t *testing.T) {
+		for _, r := range responses {
+			r.ExtraFields.RawResponse = nil
+		}
+		responses[len(responses)-1].ExtraFields.RawResponse = rawMessageStart
+
+		count, _ := countPassthroughMessageStarts(ctx, responses)
+		if count != 2 {
+			t.Fatalf("expected the old last-chunk rule to duplicate message_start (2), got %d", count)
+		}
+	})
+}

core/providers/anthropic/anthropic.go

@@ -446,7 +446,7 @@ func (provider *AnthropicProvider) ChatCompletion(ctx *schemas.BifrostContext, k
 		// Feature gating keyed to schemas.Anthropic (not provider.GetProviderKey())
 		// so custom Anthropic aliases get the same feature lookup as the typed
 		// path above (line 445), keeping raw and typed behavior in lockstep.
-		sanitized, rawErr := StripUnsupportedFieldsFromRawBody(jsonData, schemas.Anthropic, request.Model)
+		sanitized, rawErr := StripUnsupportedFieldsFromRawBody(jsonData, schemas.Anthropic, schemas.ResolveCanonicalModel(ctx, request.Model))
 		if rawErr != nil {
 			return nil, providerUtils.NewBifrostOperationError(schemas.ErrProviderRequestMarshal, rawErr)
 		}
@@ -539,7 +539,7 @@ func (provider *AnthropicProvider) ChatCompletionStream(ctx *schemas.BifrostCont
 		// Feature gating keyed to schemas.Anthropic (not provider.GetProviderKey())
 		// to keep raw and typed paths in lockstep on custom aliases — mirrors
 		// the typed path's hardcoded schemas.Anthropic at line 548.
-		sanitized, rawErr := StripUnsupportedFieldsFromRawBody(jsonData, schemas.Anthropic, request.Model)
+		sanitized, rawErr := StripUnsupportedFieldsFromRawBody(jsonData, schemas.Anthropic, schemas.ResolveCanonicalModel(ctx, request.Model))
 		if rawErr != nil {
 			return nil, providerUtils.NewBifrostOperationError(schemas.ErrProviderRequestMarshal, rawErr)
 		}
@@ -1330,6 +1330,16 @@ func HandleAnthropicResponsesStream(
 					responseChan, postHookSpanFinalizer)
 				continue
 			}
+			// Attach the upstream raw to exactly one bifrost response. Default to the last,
+			// but for the message_start expansion ([created, in_progress]) attach it to
+			// response.created
+			rawIdx := len(responses) - 1
+			for j, r := range responses {
+				if r != nil && r.Type == schemas.ResponsesStreamResponseTypeCreated {
+					rawIdx = j
+					break
+				}
+			}
 			// Handle each response in the slice
 			for i, response := range responses {
 				if response != nil {
@@ -1347,8 +1357,7 @@ func HandleAnthropicResponsesStream(
 					lastChunkTime = time.Now()
 					chunkIndex++
 
-					// Only add raw response to the last chunk of the incoming event
-					if providerUtils.ShouldSendBackRawResponse(ctx, sendBackRawResponse) && i == len(responses)-1 {
+					if providerUtils.ShouldSendBackRawResponse(ctx, sendBackRawResponse) && i == rawIdx {
 						response.ExtraFields.RawResponse = eventData
 					}
 

core/providers/anthropic/chat.go

@@ -248,6 +248,9 @@ func ToAnthropicChatRequest(ctx *schemas.BifrostContext, bifrostReq *schemas.Bif
 		MaxTokens: providerUtils.GetMaxOutputTokensOrDefault(bifrostReq.Model, AnthropicDefaultMaxTokens),
 	}
 
+	// capModel is the canonical model string used only for capability/version
+	capModel := schemas.ResolveCanonicalModel(ctx, bifrostReq.Model)
+
 	// Convert parameters
 	if bifrostReq.Params != nil {
 		anthropicReq.ExtraParams = bifrostReq.Params.ExtraParams
@@ -257,7 +260,7 @@ func ToAnthropicChatRequest(ctx *schemas.BifrostContext, bifrostReq *schemas.Bif
 
 		// Opus 4.7+ and the Fable/Mythos family reject temperature, top_p, and
 		// top_k with a 400 error.
-		if !IsAdaptiveOnlyThinkingModel(bifrostReq.Model) {
+		if !IsAdaptiveOnlyThinkingModel(capModel) {
 			// Anthropic doesn't allow both temperature and top_p to be specified.
 			// If both are present, prefer temperature (more commonly used).
 			if bifrostReq.Params.Temperature != nil {
@@ -271,12 +274,12 @@ func ToAnthropicChatRequest(ctx *schemas.BifrostContext, bifrostReq *schemas.Bif
 		// TopK — prefer the promoted neutral field; fall back to ExtraParams.
 		// Opus 4.7+ and the Fable/Mythos family reject top_k with a 400 error.
 		if bifrostReq.Params.TopK != nil {
-			if !IsAdaptiveOnlyThinkingModel(bifrostReq.Model) {
+			if !IsAdaptiveOnlyThinkingModel(capModel) {
 				anthropicReq.TopK = bifrostReq.Params.TopK
 			}
 		} else if topK, ok := schemas.SafeExtractIntPointer(bifrostReq.Params.ExtraParams["top_k"]); ok {
 			delete(anthropicReq.ExtraParams, "top_k")
-			if !IsAdaptiveOnlyThinkingModel(bifrostReq.Model) {
+			if !IsAdaptiveOnlyThinkingModel(capModel) {
 				anthropicReq.TopK = topK
 			}
 		}
@@ -458,7 +461,7 @@ func ToAnthropicChatRequest(ctx *schemas.BifrostContext, bifrostReq *schemas.Bif
 					continue
 				}
 				// Non-function tool: attempt server-tool reconstruction.
-				if converted, ok := convertServerToolToAnthropic(tool, bifrostReq.Model); ok {
+				if converted, ok := convertServerToolToAnthropic(tool, capModel); ok {
 					tools = append(tools, converted)
 				}
 			}
@@ -504,7 +507,7 @@ func ToAnthropicChatRequest(ctx *schemas.BifrostContext, bifrostReq *schemas.Bif
 		// Convert reasoning
 		if bifrostReq.Params.Reasoning != nil {
 			if bifrostReq.Params.Reasoning.MaxTokens != nil {
-				if IsAdaptiveOnlyThinkingModel(bifrostReq.Model) {
+				if IsAdaptiveOnlyThinkingModel(capModel) {
 					// Opus 4.7+ and Fable/Mythos: budget_tokens removed; adaptive thinking is the only thinking-on mode.
 					anthropicReq.Thinking = &AnthropicThinking{Type: "adaptive"}
 				} else {
@@ -524,11 +527,11 @@ func ToAnthropicChatRequest(ctx *schemas.BifrostContext, bifrostReq *schemas.Bif
 				}
 			} else if bifrostReq.Params.Reasoning.Effort != nil && *bifrostReq.Params.Reasoning.Effort != "none" {
 				effort := MapBifrostEffortToAnthropic(*bifrostReq.Params.Reasoning.Effort)
-				if SupportsAdaptiveThinking(bifrostReq.Model) {
+				if SupportsAdaptiveThinking(capModel) {
 					// Opus 4.6+ and Opus 4.7+: adaptive thinking + native effort
 					anthropicReq.Thinking = &AnthropicThinking{Type: "adaptive"}
 					setEffortOnOutputConfig(anthropicReq, effort)
-				} else if SupportsNativeEffort(bifrostReq.Model) {
+				} else if SupportsNativeEffort(capModel) {
 					// Opus 4.5: native effort + budget_tokens thinking
 					setEffortOnOutputConfig(anthropicReq, effort)
 					budgetTokens, err := providerUtils.GetBudgetTokensFromReasoningEffort(effort, MinimumReasoningMaxTokens, anthropicReq.MaxTokens)
@@ -550,7 +553,7 @@ func ToAnthropicChatRequest(ctx *schemas.BifrostContext, bifrostReq *schemas.Bif
 						BudgetTokens: schemas.Ptr(budgetTokens),
 					}
 				}
-			} else if !IsFableFamily(bifrostReq.Model) {
+			} else if !IsFableFamily(capModel) {
 				// Fable/Mythos reject thinking:{type:"disabled"} with a 400 —
 				// adaptive thinking is always on and cannot be disabled. Omit
 				// the thinking param entirely for that family; all other models
@@ -572,7 +575,7 @@ func ToAnthropicChatRequest(ctx *schemas.BifrostContext, bifrostReq *schemas.Bif
 			if anthropicReq.Thinking != nil && anthropicReq.Thinking.Type != "disabled" {
 				if bifrostReq.Params.Reasoning.Display != nil {
 					anthropicReq.Thinking.Display = bifrostReq.Params.Reasoning.Display
-				} else if IsAdaptiveOnlyThinkingModel(bifrostReq.Model) {
+				} else if IsAdaptiveOnlyThinkingModel(capModel) {
 					anthropicReq.Thinking.Display = schemas.Ptr("summarized")
 				}
 			}
@@ -593,7 +596,7 @@ func ToAnthropicChatRequest(ctx *schemas.BifrostContext, bifrostReq *schemas.Bif
 	// system message and is emitted as role:"system" in the messages array
 	// (Anthropic API + Opus 4.8+ only).
 	seenConversation := false
-	midConvSystemSupported := SupportsMidConversationSystem(bifrostReq.Provider, bifrostReq.Model)
+	midConvSystemSupported := SupportsMidConversationSystem(bifrostReq.Provider, capModel)
 
 	i := 0
 	for i < len(messages) {
@@ -823,7 +826,7 @@ func ToAnthropicChatRequest(ctx *schemas.BifrostContext, bifrostReq *schemas.Bif
 	// Strip request- and tool-level fields the target Anthropic-family
 	// provider does not support. Fail-closed tool validation stays in
 	// ValidateToolsForProvider; this is strip-silently for additive fields.
-	stripUnsupportedAnthropicFields(anthropicReq, bifrostReq.Provider, bifrostReq.Model)
+	stripUnsupportedAnthropicFields(anthropicReq, bifrostReq.Provider, capModel)
 
 	return anthropicReq, nil
 }

core/providers/anthropic/requestbuilder.go

@@ -86,6 +86,9 @@ func BuildAnthropicResponsesRequestBody(ctx *schemas.BifrostContext, request *sc
 		return nil, nil
 	}
 
+	// capModel is the canonical model used for capability gating in the raw-body
+	capModel := schemas.ResolveCanonicalModel(ctx, request.Model)
+
 	newErr := func(msg string, err error, reqBody []byte) *schemas.BifrostError {
 		return providerUtils.EnrichError(
 			ctx,
@@ -175,7 +178,7 @@ func BuildAnthropicResponsesRequestBody(ctx *schemas.BifrostContext, request *sc
 			// request.Model is the alias-resolved model id; pass it so
 			// computer-use / text-editor / bash tools get normalized to the
 			// canonical {type, name} pair Anthropic expects for the model's generation.
-			jsonBody, err = RemapRawToolVersionsForProvider(jsonBody, cfg.Provider, request.Model)
+			jsonBody, err = RemapRawToolVersionsForProvider(jsonBody, cfg.Provider, capModel)
 			if err != nil {
 				return nil, newErr(err.Error(), nil, jsonBody)
 			}
@@ -188,7 +191,7 @@ func BuildAnthropicResponsesRequestBody(ctx *schemas.BifrostContext, request *sc
 			}
 		}
 
-		jsonBody, err = StripUnsupportedFieldsFromRawBody(jsonBody, cfg.Provider, request.Model)
+		jsonBody, err = StripUnsupportedFieldsFromRawBody(jsonBody, cfg.Provider, capModel)
 		if err != nil {
 			return nil, newErr(schemas.ErrProviderRequestMarshal, err, jsonBody)
 		}