753 lines
24 KiB
Go
753 lines
24 KiB
Go
package anthropic
|
|
|
|
import (
|
|
"encoding/json"
|
|
"strings"
|
|
"testing"
|
|
|
|
"github.com/maximhq/bifrost/core/schemas"
|
|
)
|
|
|
|
func TestToAnthropicChatRequest_PreservesPropertyOrder(t *testing.T) {
|
|
params := &schemas.ToolFunctionParameters{
|
|
Type: "object",
|
|
Properties: schemas.NewOrderedMapFromPairs(
|
|
schemas.KV("chain_of_thought", schemas.NewOrderedMapFromPairs(
|
|
schemas.KV("type", "string"),
|
|
schemas.KV("description", "Reasoning steps"),
|
|
)),
|
|
schemas.KV("answer", schemas.NewOrderedMapFromPairs(
|
|
schemas.KV("type", "string"),
|
|
schemas.KV("description", "The answer"),
|
|
)),
|
|
schemas.KV("citations", schemas.NewOrderedMapFromPairs(
|
|
schemas.KV("type", "array"),
|
|
)),
|
|
schemas.KV("is_unanswered", schemas.NewOrderedMapFromPairs(
|
|
schemas.KV("type", "boolean"),
|
|
)),
|
|
),
|
|
Required: []string{"answer", "is_unanswered"},
|
|
}
|
|
|
|
bifrostReq := &schemas.BifrostChatRequest{
|
|
Provider: schemas.Anthropic,
|
|
Model: "claude-sonnet-4-20250514",
|
|
Input: []schemas.ChatMessage{{
|
|
Role: schemas.ChatMessageRoleUser,
|
|
Content: &schemas.ChatMessageContent{ContentStr: schemas.Ptr("test")},
|
|
}},
|
|
Params: &schemas.ChatParameters{
|
|
Tools: []schemas.ChatTool{{
|
|
Type: schemas.ChatToolTypeFunction,
|
|
Function: &schemas.ChatToolFunction{
|
|
Name: "AnswerResponseModel",
|
|
Description: schemas.Ptr("Extract answer"),
|
|
Parameters: params,
|
|
},
|
|
}},
|
|
},
|
|
}
|
|
|
|
ctx, cancel := schemas.NewBifrostContextWithCancel(nil)
|
|
defer cancel()
|
|
result, err := ToAnthropicChatRequest(ctx, bifrostReq)
|
|
if err != nil {
|
|
t.Fatalf("unexpected error: %v", err)
|
|
}
|
|
|
|
if len(result.Tools) == 0 {
|
|
t.Fatal("expected at least one tool")
|
|
}
|
|
|
|
inputSchema := result.Tools[0].InputSchema
|
|
if inputSchema == nil {
|
|
t.Fatal("expected InputSchema to be non-nil")
|
|
}
|
|
|
|
// CoT: property order preserved
|
|
keys := inputSchema.Properties.Keys()
|
|
expected := []string{"chain_of_thought", "answer", "citations", "is_unanswered"}
|
|
if len(keys) != len(expected) {
|
|
t.Fatalf("expected %d properties, got %d: %v", len(expected), len(keys), keys)
|
|
}
|
|
for i, k := range expected {
|
|
if keys[i] != k {
|
|
t.Errorf("property %d: expected %q, got %q (full order: %v)", i, k, keys[i], keys)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestToAnthropicChatRequest_CachingDeterminism(t *testing.T) {
|
|
makeReq := func(props *schemas.OrderedMap) *schemas.BifrostChatRequest {
|
|
return &schemas.BifrostChatRequest{
|
|
Provider: schemas.Anthropic,
|
|
Model: "claude-sonnet-4-20250514",
|
|
Input: []schemas.ChatMessage{{
|
|
Role: schemas.ChatMessageRoleUser,
|
|
Content: &schemas.ChatMessageContent{ContentStr: new("test")},
|
|
}},
|
|
Params: &schemas.ChatParameters{
|
|
Tools: []schemas.ChatTool{{
|
|
Type: schemas.ChatToolTypeFunction,
|
|
Function: &schemas.ChatToolFunction{
|
|
Name: "test",
|
|
Parameters: &schemas.ToolFunctionParameters{
|
|
Type: "object",
|
|
Properties: props,
|
|
},
|
|
},
|
|
}},
|
|
},
|
|
}
|
|
}
|
|
|
|
// Version A: type before description
|
|
propsA := schemas.NewOrderedMapFromPairs(
|
|
schemas.KV("reasoning", schemas.NewOrderedMapFromPairs(
|
|
schemas.KV("type", "string"),
|
|
schemas.KV("description", "Step by step"),
|
|
)),
|
|
schemas.KV("answer", schemas.NewOrderedMapFromPairs(
|
|
schemas.KV("type", "string"),
|
|
schemas.KV("description", "Final answer"),
|
|
)),
|
|
)
|
|
|
|
// Version B: description before type
|
|
propsB := schemas.NewOrderedMapFromPairs(
|
|
schemas.KV("reasoning", schemas.NewOrderedMapFromPairs(
|
|
schemas.KV("description", "Step by step"),
|
|
schemas.KV("type", "string"),
|
|
)),
|
|
schemas.KV("answer", schemas.NewOrderedMapFromPairs(
|
|
schemas.KV("description", "Final answer"),
|
|
schemas.KV("type", "string"),
|
|
)),
|
|
)
|
|
|
|
ctx, cancel := schemas.NewBifrostContextWithCancel(nil)
|
|
defer cancel()
|
|
resultA, err := ToAnthropicChatRequest(ctx, makeReq(propsA))
|
|
if err != nil {
|
|
t.Fatalf("unexpected error: %v", err)
|
|
}
|
|
resultB, err := ToAnthropicChatRequest(ctx, makeReq(propsB))
|
|
if err != nil {
|
|
t.Fatalf("unexpected error: %v", err)
|
|
}
|
|
|
|
jsonA, err := schemas.Marshal(resultA.Tools[0].InputSchema)
|
|
if err != nil {
|
|
t.Fatalf("failed to marshal params A: %v", err)
|
|
}
|
|
jsonB, err := schemas.Marshal(resultB.Tools[0].InputSchema)
|
|
if err != nil {
|
|
t.Fatalf("failed to marshal params B: %v", err)
|
|
}
|
|
|
|
if string(jsonA) != string(jsonB) {
|
|
t.Errorf("caching broken: same schema produced different JSON\nA: %s\nB: %s", jsonA, jsonB)
|
|
}
|
|
}
|
|
|
|
func TestToAnthropicChatRequest_NestedProperties_Preserved(t *testing.T) {
|
|
params := &schemas.ToolFunctionParameters{
|
|
Type: "object",
|
|
Properties: schemas.NewOrderedMapFromPairs(
|
|
schemas.KV("output", schemas.NewOrderedMapFromPairs(
|
|
schemas.KV("type", "object"),
|
|
schemas.KV("properties", schemas.NewOrderedMapFromPairs(
|
|
schemas.KV("verdict", schemas.NewOrderedMapFromPairs(schemas.KV("type", "string"))),
|
|
schemas.KV("score", schemas.NewOrderedMapFromPairs(schemas.KV("type", "number"))),
|
|
schemas.KV("explanation", schemas.NewOrderedMapFromPairs(schemas.KV("type", "string"))),
|
|
)),
|
|
)),
|
|
schemas.KV("reasoning", schemas.NewOrderedMapFromPairs(schemas.KV("type", "string"))),
|
|
),
|
|
}
|
|
|
|
bifrostReq := &schemas.BifrostChatRequest{
|
|
Provider: schemas.Anthropic,
|
|
Model: "claude-sonnet-4-20250514",
|
|
Input: []schemas.ChatMessage{{
|
|
Role: schemas.ChatMessageRoleUser,
|
|
Content: &schemas.ChatMessageContent{ContentStr: schemas.Ptr("test")},
|
|
}},
|
|
Params: &schemas.ChatParameters{
|
|
Tools: []schemas.ChatTool{{
|
|
Type: schemas.ChatToolTypeFunction,
|
|
Function: &schemas.ChatToolFunction{
|
|
Name: "nested_tool",
|
|
Parameters: params,
|
|
},
|
|
}},
|
|
},
|
|
}
|
|
|
|
ctx, cancel := schemas.NewBifrostContextWithCancel(nil)
|
|
defer cancel()
|
|
result, err := ToAnthropicChatRequest(ctx, bifrostReq)
|
|
if err != nil {
|
|
t.Fatalf("unexpected error: %v", err)
|
|
}
|
|
|
|
if len(result.Tools) == 0 {
|
|
t.Fatal("expected at least one tool")
|
|
}
|
|
inputSchema := result.Tools[0].InputSchema
|
|
|
|
// CoT: top-level property order preserved
|
|
keys := inputSchema.Properties.Keys()
|
|
if len(keys) != 2 || keys[0] != "output" || keys[1] != "reasoning" {
|
|
t.Errorf("expected top-level property order [output, reasoning], got %v", keys)
|
|
}
|
|
|
|
// CoT: nested property order preserved
|
|
output, ok := inputSchema.Properties.Get("output")
|
|
if !ok {
|
|
t.Fatal("expected output property")
|
|
}
|
|
outputOM, ok := output.(*schemas.OrderedMap)
|
|
if !ok {
|
|
t.Fatalf("expected output to be *schemas.OrderedMap, got %T", output)
|
|
}
|
|
nestedProps, ok := outputOM.Get("properties")
|
|
if !ok {
|
|
t.Fatal("expected nested properties in output")
|
|
}
|
|
nestedPropsOM, ok := nestedProps.(*schemas.OrderedMap)
|
|
if !ok {
|
|
t.Fatalf("expected nested properties to be *schemas.OrderedMap, got %T", nestedProps)
|
|
}
|
|
nestedKeys := nestedPropsOM.Keys()
|
|
if len(nestedKeys) != 3 || nestedKeys[0] != "verdict" || nestedKeys[1] != "score" || nestedKeys[2] != "explanation" {
|
|
t.Errorf("expected nested property order [verdict, score, explanation], got %v", nestedKeys)
|
|
}
|
|
}
|
|
|
|
// TestToAnthropicChatRequest_ToolInputKeyOrderPreservation verifies that tool_use input
|
|
// arguments preserve the client's original key ordering after conversion to Anthropic format.
|
|
// This is critical for prompt caching, which relies on exact byte-for-byte prefix matching.
|
|
// The test uses multiple parallel tool calls in a single assistant message — each with
|
|
// a different key ordering — matching real-world Claude Code usage patterns.
|
|
func TestToAnthropicChatRequest_ToolInputKeyOrderPreservation(t *testing.T) {
|
|
bifrostReq := &schemas.BifrostChatRequest{
|
|
Provider: schemas.Anthropic,
|
|
Model: "claude-sonnet-4-20250514",
|
|
Input: []schemas.ChatMessage{
|
|
{
|
|
Role: schemas.ChatMessageRoleUser,
|
|
Content: &schemas.ChatMessageContent{ContentStr: schemas.Ptr("test")},
|
|
},
|
|
{
|
|
// Multiple parallel tool calls with different key orderings per block
|
|
Role: schemas.ChatMessageRoleAssistant,
|
|
ChatAssistantMessage: &schemas.ChatAssistantMessage{
|
|
ToolCalls: []schemas.ChatAssistantMessageToolCall{
|
|
{
|
|
Index: 0,
|
|
Type: schemas.Ptr("function"),
|
|
ID: schemas.Ptr("toolu_vrtx_013t7gabfKz98BKpdwrnS6LP"),
|
|
Function: schemas.ChatAssistantMessageToolCallFunction{
|
|
Name: schemas.Ptr("bash"),
|
|
Arguments: `{"description":"Find references to auth_injector quickly","timeout":30000,"command":"grep -r \"auth_injector\" . --include=\"Makefile\" -l 2>/dev/null"}`,
|
|
},
|
|
},
|
|
{
|
|
Index: 1,
|
|
Type: schemas.Ptr("function"),
|
|
ID: schemas.Ptr("toolu_vrtx_01K2kr3wi7M4RriLgE7Kq3vJ"),
|
|
Function: schemas.ChatAssistantMessageToolCallFunction{
|
|
Name: schemas.Ptr("bash"),
|
|
Arguments: `{"command":"git diff main...HEAD --stat","description":"Show diff of commits in branch"}`,
|
|
},
|
|
},
|
|
{
|
|
Index: 2,
|
|
Type: schemas.Ptr("function"),
|
|
ID: schemas.Ptr("toolu_vrtx_01D1mMkcvpfqGrEhkcxUQpGc"),
|
|
Function: schemas.ChatAssistantMessageToolCallFunction{
|
|
Name: schemas.Ptr("bash"),
|
|
Arguments: `{"command":"git log main..HEAD --format=\"%H %s\" | head -20","description":"Show detailed commits in branch"}`,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
}
|
|
|
|
ctx, cancel := schemas.NewBifrostContextWithCancel(nil)
|
|
defer cancel()
|
|
result, err := ToAnthropicChatRequest(ctx, bifrostReq)
|
|
if err != nil {
|
|
t.Fatalf("unexpected error: %v", err)
|
|
}
|
|
|
|
// Collect all tool_use content blocks
|
|
var toolUseBlocks []AnthropicContentBlock
|
|
for _, msg := range result.Messages {
|
|
for _, block := range msg.Content.ContentBlocks {
|
|
if block.Type == AnthropicContentBlockTypeToolUse {
|
|
toolUseBlocks = append(toolUseBlocks, block)
|
|
}
|
|
}
|
|
}
|
|
|
|
if len(toolUseBlocks) != 3 {
|
|
t.Fatalf("expected 3 tool_use blocks, got %d", len(toolUseBlocks))
|
|
}
|
|
|
|
// Block 0: keys should be description, timeout, command (NOT alphabetical)
|
|
json0, _ := json.Marshal(toolUseBlocks[0].Input)
|
|
s0 := string(json0)
|
|
descIdx0 := strings.Index(s0, `"description"`)
|
|
timeIdx0 := strings.Index(s0, `"timeout"`)
|
|
cmdIdx0 := strings.Index(s0, `"command"`)
|
|
if descIdx0 < 0 || timeIdx0 < 0 || cmdIdx0 < 0 {
|
|
t.Fatalf("block 0: missing expected key(s) in: %s", s0)
|
|
}
|
|
if !(descIdx0 < timeIdx0 && timeIdx0 < cmdIdx0) {
|
|
t.Errorf("block 0: key order not preserved, expected description < timeout < command in: %s", s0)
|
|
}
|
|
|
|
// Block 1: keys should be command, description (NOT alphabetical)
|
|
json1, _ := json.Marshal(toolUseBlocks[1].Input)
|
|
s1 := string(json1)
|
|
cmdIdx1 := strings.Index(s1, `"command"`)
|
|
descIdx1 := strings.Index(s1, `"description"`)
|
|
if cmdIdx1 < 0 || descIdx1 < 0 {
|
|
t.Fatalf("block 1: missing expected key(s) in: %s", s1)
|
|
}
|
|
if !(cmdIdx1 < descIdx1) {
|
|
t.Errorf("block 1: key order not preserved, expected command < description in: %s", s1)
|
|
}
|
|
|
|
// Block 2: keys should be command, description (same as block 1)
|
|
json2, _ := json.Marshal(toolUseBlocks[2].Input)
|
|
s2 := string(json2)
|
|
cmdIdx2 := strings.Index(s2, `"command"`)
|
|
descIdx2 := strings.Index(s2, `"description"`)
|
|
if cmdIdx2 < 0 || descIdx2 < 0 {
|
|
t.Fatalf("block 2: missing expected key(s) in: %s", s2)
|
|
}
|
|
if !(cmdIdx2 < descIdx2) {
|
|
t.Errorf("block 2: key order not preserved, expected command < description in: %s", s2)
|
|
}
|
|
}
|
|
|
|
func TestToBifrostChatResponse_MultipleTextBlocksWithThinking(t *testing.T) {
|
|
thinkingText := "Let me reason step by step about this problem."
|
|
textBlock1 := "The answer is 42."
|
|
textBlock2 := "Here is why that is the case."
|
|
signature := "sig_abc123"
|
|
|
|
response := &AnthropicMessageResponse{
|
|
ID: "msg_test123",
|
|
Type: "message",
|
|
Role: "assistant",
|
|
Model: "claude-opus-4-6-20250514",
|
|
Content: []AnthropicContentBlock{
|
|
{
|
|
Type: AnthropicContentBlockTypeThinking,
|
|
Thinking: &thinkingText,
|
|
Signature: &signature,
|
|
},
|
|
{
|
|
Type: AnthropicContentBlockTypeText,
|
|
Text: &textBlock1,
|
|
},
|
|
{
|
|
Type: AnthropicContentBlockTypeText,
|
|
Text: &textBlock2,
|
|
},
|
|
},
|
|
StopReason: "end_turn",
|
|
Usage: &AnthropicUsage{
|
|
InputTokens: 100,
|
|
OutputTokens: 50,
|
|
},
|
|
}
|
|
|
|
ctx, cancel := schemas.NewBifrostContextWithCancel(nil)
|
|
defer cancel()
|
|
result := response.ToBifrostChatResponse(ctx)
|
|
|
|
if result == nil {
|
|
t.Fatal("expected non-nil result")
|
|
}
|
|
|
|
// With multiple text blocks, ToBifrostChatResponse preserves them as ContentBlocks
|
|
// (only a single text block collapses to ContentStr — see chat.go:812-815).
|
|
// Thinking flows through ReasoningDetails below, not ContentStr.
|
|
choice := result.Choices[0]
|
|
msg := choice.ChatNonStreamResponseChoice.Message
|
|
if msg.Content.ContentStr != nil {
|
|
t.Errorf("expected ContentStr to be nil with multiple text blocks, got %q", *msg.Content.ContentStr)
|
|
}
|
|
if len(msg.Content.ContentBlocks) != 2 {
|
|
t.Fatalf("expected 2 content blocks (one per text block), got %d", len(msg.Content.ContentBlocks))
|
|
}
|
|
if msg.Content.ContentBlocks[0].Text == nil || *msg.Content.ContentBlocks[0].Text != textBlock1 {
|
|
t.Errorf("block 0 text mismatch: got %v, want %q", msg.Content.ContentBlocks[0].Text, textBlock1)
|
|
}
|
|
if msg.Content.ContentBlocks[1].Text == nil || *msg.Content.ContentBlocks[1].Text != textBlock2 {
|
|
t.Errorf("block 1 text mismatch: got %v, want %q", msg.Content.ContentBlocks[1].Text, textBlock2)
|
|
}
|
|
|
|
// Thinking is surfaced via ReasoningDetails with the signature preserved
|
|
// (see chat.go:798-807).
|
|
if msg.ChatAssistantMessage == nil {
|
|
t.Fatal("expected ChatAssistantMessage to be non-nil")
|
|
}
|
|
rd := msg.ChatAssistantMessage.ReasoningDetails
|
|
if len(rd) != 1 {
|
|
t.Fatalf("expected 1 reasoning details entry (the thinking block), got %d", len(rd))
|
|
}
|
|
if rd[0].Type != schemas.BifrostReasoningDetailsTypeText {
|
|
t.Errorf("expected reasoning detail type %s, got %s", schemas.BifrostReasoningDetailsTypeText, rd[0].Type)
|
|
}
|
|
if rd[0].Signature == nil || *rd[0].Signature != signature {
|
|
t.Error("expected thinking signature to be preserved on reasoning detail")
|
|
}
|
|
if rd[0].Text == nil || *rd[0].Text != thinkingText {
|
|
t.Errorf("expected reasoning text to match thinking text")
|
|
}
|
|
}
|
|
|
|
func TestToBifrostChatResponse_SingleTextBlockNoThinking(t *testing.T) {
|
|
// Verify existing behavior: single text block without thinking collapses to string
|
|
text := "Simple response"
|
|
response := &AnthropicMessageResponse{
|
|
ID: "msg_simple",
|
|
Type: "message",
|
|
Role: "assistant",
|
|
Model: "claude-sonnet-4-6-20250514",
|
|
Content: []AnthropicContentBlock{
|
|
{Type: AnthropicContentBlockTypeText, Text: &text},
|
|
},
|
|
StopReason: "end_turn",
|
|
Usage: &AnthropicUsage{InputTokens: 10, OutputTokens: 5},
|
|
}
|
|
|
|
ctx, cancel := schemas.NewBifrostContextWithCancel(nil)
|
|
defer cancel()
|
|
result := response.ToBifrostChatResponse(ctx)
|
|
|
|
msg := result.Choices[0].ChatNonStreamResponseChoice.Message
|
|
if msg.Content.ContentStr == nil || *msg.Content.ContentStr != text {
|
|
t.Error("expected ContentStr to be the text")
|
|
}
|
|
if msg.Content.ContentBlocks != nil {
|
|
t.Error("expected ContentBlocks to be nil")
|
|
}
|
|
// No reasoning details for plain text
|
|
if msg.ChatAssistantMessage != nil && len(msg.ChatAssistantMessage.ReasoningDetails) > 0 {
|
|
t.Error("expected no reasoning details for single text block without thinking")
|
|
}
|
|
}
|
|
|
|
func TestToAnthropicChatRequest_BoundaryMismatchFallback(t *testing.T) {
|
|
// If content was modified by the client, boundaries won't match — fall back to single text block
|
|
signature := "sig_fallback"
|
|
modifiedContent := "The user edited this content"
|
|
|
|
bifrostReq := &schemas.BifrostChatRequest{
|
|
Provider: schemas.Anthropic,
|
|
Model: "claude-opus-4-6-20250514",
|
|
Input: []schemas.ChatMessage{
|
|
{
|
|
Role: schemas.ChatMessageRoleUser,
|
|
Content: &schemas.ChatMessageContent{ContentStr: schemas.Ptr("Hi")},
|
|
},
|
|
{
|
|
Role: schemas.ChatMessageRoleAssistant,
|
|
Content: &schemas.ChatMessageContent{ContentStr: &modifiedContent},
|
|
ChatAssistantMessage: &schemas.ChatAssistantMessage{
|
|
ReasoningDetails: []schemas.ChatReasoningDetails{
|
|
{Index: 0, Type: schemas.BifrostReasoningDetailsTypeText, Text: &modifiedContent, Signature: &signature},
|
|
},
|
|
},
|
|
},
|
|
{
|
|
Role: schemas.ChatMessageRoleUser,
|
|
Content: &schemas.ChatMessageContent{ContentStr: schemas.Ptr("Continue")},
|
|
},
|
|
},
|
|
}
|
|
|
|
ctx, cancel := schemas.NewBifrostContextWithCancel(nil)
|
|
defer cancel()
|
|
result, err := ToAnthropicChatRequest(ctx, bifrostReq)
|
|
if err != nil {
|
|
t.Fatalf("unexpected error: %v", err)
|
|
}
|
|
|
|
var assistantMsg *AnthropicMessage
|
|
for i := range result.Messages {
|
|
if result.Messages[i].Role == "assistant" {
|
|
assistantMsg = &result.Messages[i]
|
|
break
|
|
}
|
|
}
|
|
if assistantMsg == nil {
|
|
t.Fatal("expected assistant message")
|
|
}
|
|
|
|
// Should have thinking block (from reasoning_details with signature) + single text fallback
|
|
blocks := assistantMsg.Content.ContentBlocks
|
|
// First block: thinking (from reasoning_details, text is nil since it was cleared)
|
|
// Plus: fallback single text block with the full modified content
|
|
foundText := false
|
|
for _, block := range blocks {
|
|
if block.Type == AnthropicContentBlockTypeText {
|
|
if block.Text != nil && *block.Text == modifiedContent {
|
|
foundText = true
|
|
}
|
|
}
|
|
}
|
|
if !foundText {
|
|
t.Error("expected fallback to single text block with full content")
|
|
}
|
|
}
|
|
|
|
func TestToAnthropicChatRequest_NormalFlowUnchanged(t *testing.T) {
|
|
// Verify that the normal multi-turn flow (reasoning_details with text + signature,
|
|
// no bifrost.content_blocks) produces the same output as before.
|
|
thinkingText := "I need to think about this carefully"
|
|
signature := "sig_normal"
|
|
responseText := "Here is my answer"
|
|
|
|
bifrostReq := &schemas.BifrostChatRequest{
|
|
Provider: schemas.Anthropic,
|
|
Model: "claude-opus-4-6-20250514",
|
|
Input: []schemas.ChatMessage{
|
|
{
|
|
Role: schemas.ChatMessageRoleUser,
|
|
Content: &schemas.ChatMessageContent{ContentStr: schemas.Ptr("What is 2+2?")},
|
|
},
|
|
{
|
|
Role: schemas.ChatMessageRoleAssistant,
|
|
Content: &schemas.ChatMessageContent{ContentStr: &responseText},
|
|
ChatAssistantMessage: &schemas.ChatAssistantMessage{
|
|
ReasoningDetails: []schemas.ChatReasoningDetails{
|
|
{
|
|
Index: 0,
|
|
Type: schemas.BifrostReasoningDetailsTypeText,
|
|
Text: &thinkingText,
|
|
Signature: &signature,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
{
|
|
Role: schemas.ChatMessageRoleUser,
|
|
Content: &schemas.ChatMessageContent{ContentStr: schemas.Ptr("Are you sure?")},
|
|
},
|
|
},
|
|
}
|
|
|
|
ctx, cancel := schemas.NewBifrostContextWithCancel(nil)
|
|
defer cancel()
|
|
result, err := ToAnthropicChatRequest(ctx, bifrostReq)
|
|
if err != nil {
|
|
t.Fatalf("unexpected error: %v", err)
|
|
}
|
|
|
|
var assistantMsg *AnthropicMessage
|
|
for i := range result.Messages {
|
|
if result.Messages[i].Role == "assistant" {
|
|
assistantMsg = &result.Messages[i]
|
|
break
|
|
}
|
|
}
|
|
if assistantMsg == nil {
|
|
t.Fatal("expected assistant message")
|
|
}
|
|
|
|
blocks := assistantMsg.Content.ContentBlocks
|
|
if len(blocks) != 2 {
|
|
t.Fatalf("expected 2 content blocks (thinking + text), got %d", len(blocks))
|
|
}
|
|
|
|
// Block 0: thinking with original text and signature
|
|
if blocks[0].Type != AnthropicContentBlockTypeThinking {
|
|
t.Errorf("block 0: expected thinking, got %s", blocks[0].Type)
|
|
}
|
|
if blocks[0].Thinking == nil || *blocks[0].Thinking != thinkingText {
|
|
t.Errorf("block 0: expected thinking text %q, got %v", thinkingText, blocks[0].Thinking)
|
|
}
|
|
if blocks[0].Signature == nil || *blocks[0].Signature != signature {
|
|
t.Errorf("block 0: expected signature %q, got %v", signature, blocks[0].Signature)
|
|
}
|
|
|
|
// Block 1: text with response
|
|
if blocks[1].Type != AnthropicContentBlockTypeText {
|
|
t.Errorf("block 1: expected text, got %s", blocks[1].Type)
|
|
}
|
|
if blocks[1].Text == nil || *blocks[1].Text != responseText {
|
|
t.Errorf("block 1: expected text %q, got %v", responseText, blocks[1].Text)
|
|
}
|
|
}
|
|
|
|
func TestToAnthropicChatRequest_Opus47_StripsTemperatureTopPTopK(t *testing.T) {
|
|
temp := 0.7
|
|
topP := 0.9
|
|
|
|
bifrostReq := &schemas.BifrostChatRequest{
|
|
Provider: schemas.Anthropic,
|
|
Model: "claude-opus-4-7-20260401",
|
|
Input: []schemas.ChatMessage{
|
|
{Role: schemas.ChatMessageRoleUser, Content: &schemas.ChatMessageContent{ContentStr: schemas.Ptr("hi")}},
|
|
},
|
|
Params: &schemas.ChatParameters{
|
|
Temperature: &temp,
|
|
TopP: &topP,
|
|
ExtraParams: map[string]interface{}{"top_k": 40},
|
|
},
|
|
}
|
|
|
|
ctx, cancel := schemas.NewBifrostContextWithCancel(nil)
|
|
defer cancel()
|
|
result, err := ToAnthropicChatRequest(ctx, bifrostReq)
|
|
if err != nil {
|
|
t.Fatalf("unexpected error: %v", err)
|
|
}
|
|
|
|
if result.Temperature != nil {
|
|
t.Errorf("expected Temperature to be nil for Opus 4.7, got %v", result.Temperature)
|
|
}
|
|
if result.TopP != nil {
|
|
t.Errorf("expected TopP to be nil for Opus 4.7, got %v", result.TopP)
|
|
}
|
|
if result.TopK != nil {
|
|
t.Errorf("expected TopK to be nil for Opus 4.7, got %v", result.TopK)
|
|
}
|
|
}
|
|
|
|
func TestToAnthropicChatRequest_NonOpus47_PreservesTemperature(t *testing.T) {
|
|
temp := 0.7
|
|
|
|
bifrostReq := &schemas.BifrostChatRequest{
|
|
Provider: schemas.Anthropic,
|
|
Model: "claude-opus-4-6-20250514",
|
|
Input: []schemas.ChatMessage{
|
|
{Role: schemas.ChatMessageRoleUser, Content: &schemas.ChatMessageContent{ContentStr: schemas.Ptr("hi")}},
|
|
},
|
|
Params: &schemas.ChatParameters{
|
|
Temperature: &temp,
|
|
},
|
|
}
|
|
|
|
ctx, cancel := schemas.NewBifrostContextWithCancel(nil)
|
|
defer cancel()
|
|
result, err := ToAnthropicChatRequest(ctx, bifrostReq)
|
|
if err != nil {
|
|
t.Fatalf("unexpected error: %v", err)
|
|
}
|
|
|
|
if result.Temperature == nil || *result.Temperature != temp {
|
|
t.Errorf("expected Temperature %v, got %v", temp, result.Temperature)
|
|
}
|
|
}
|
|
|
|
func TestToAnthropicChatRequest_Opus47_ReasoningMaxTokens_AdaptiveOnly(t *testing.T) {
|
|
maxTok := 2048
|
|
|
|
bifrostReq := &schemas.BifrostChatRequest{
|
|
Provider: schemas.Anthropic,
|
|
Model: "claude-opus-4-7-20260401",
|
|
Input: []schemas.ChatMessage{
|
|
{Role: schemas.ChatMessageRoleUser, Content: &schemas.ChatMessageContent{ContentStr: schemas.Ptr("think")}},
|
|
},
|
|
Params: &schemas.ChatParameters{
|
|
MaxCompletionTokens: schemas.Ptr(8192),
|
|
Reasoning: &schemas.ChatReasoning{MaxTokens: &maxTok},
|
|
},
|
|
}
|
|
|
|
ctx, cancel := schemas.NewBifrostContextWithCancel(nil)
|
|
defer cancel()
|
|
result, err := ToAnthropicChatRequest(ctx, bifrostReq)
|
|
if err != nil {
|
|
t.Fatalf("unexpected error: %v", err)
|
|
}
|
|
|
|
if result.Thinking == nil {
|
|
t.Fatal("expected Thinking to be set")
|
|
}
|
|
if result.Thinking.Type != "adaptive" {
|
|
t.Errorf("expected thinking type 'adaptive' for Opus 4.7, got %q", result.Thinking.Type)
|
|
}
|
|
if result.Thinking.BudgetTokens != nil {
|
|
t.Errorf("expected BudgetTokens to be nil for Opus 4.7, got %v", result.Thinking.BudgetTokens)
|
|
}
|
|
}
|
|
|
|
func TestToAnthropicChatRequest_NonOpus47_ReasoningMaxTokens_EnabledWithBudget(t *testing.T) {
|
|
maxTok := 2048
|
|
|
|
bifrostReq := &schemas.BifrostChatRequest{
|
|
Provider: schemas.Anthropic,
|
|
Model: "claude-opus-4-6-20250514",
|
|
Input: []schemas.ChatMessage{
|
|
{Role: schemas.ChatMessageRoleUser, Content: &schemas.ChatMessageContent{ContentStr: schemas.Ptr("think")}},
|
|
},
|
|
Params: &schemas.ChatParameters{
|
|
MaxCompletionTokens: schemas.Ptr(8192),
|
|
Reasoning: &schemas.ChatReasoning{MaxTokens: &maxTok},
|
|
},
|
|
}
|
|
|
|
ctx, cancel := schemas.NewBifrostContextWithCancel(nil)
|
|
defer cancel()
|
|
result, err := ToAnthropicChatRequest(ctx, bifrostReq)
|
|
if err != nil {
|
|
t.Fatalf("unexpected error: %v", err)
|
|
}
|
|
|
|
if result.Thinking == nil {
|
|
t.Fatal("expected Thinking to be set")
|
|
}
|
|
if result.Thinking.Type != "enabled" {
|
|
t.Errorf("expected thinking type 'enabled' for Opus 4.6, got %q", result.Thinking.Type)
|
|
}
|
|
if result.Thinking.BudgetTokens == nil || *result.Thinking.BudgetTokens != maxTok {
|
|
t.Errorf("expected BudgetTokens %d, got %v", maxTok, result.Thinking.BudgetTokens)
|
|
}
|
|
}
|
|
|
|
func TestToAnthropicChatRequest_Opus47_ReasoningEffort_AdaptiveWithEffort(t *testing.T) {
|
|
effort := "high"
|
|
|
|
bifrostReq := &schemas.BifrostChatRequest{
|
|
Provider: schemas.Anthropic,
|
|
Model: "claude-opus-4-7-20260401",
|
|
Input: []schemas.ChatMessage{
|
|
{Role: schemas.ChatMessageRoleUser, Content: &schemas.ChatMessageContent{ContentStr: schemas.Ptr("think")}},
|
|
},
|
|
Params: &schemas.ChatParameters{
|
|
MaxCompletionTokens: schemas.Ptr(8192),
|
|
Reasoning: &schemas.ChatReasoning{Effort: &effort},
|
|
},
|
|
}
|
|
|
|
ctx, cancel := schemas.NewBifrostContextWithCancel(nil)
|
|
defer cancel()
|
|
result, err := ToAnthropicChatRequest(ctx, bifrostReq)
|
|
if err != nil {
|
|
t.Fatalf("unexpected error: %v", err)
|
|
}
|
|
|
|
if result.Thinking == nil {
|
|
t.Fatal("expected Thinking to be set")
|
|
}
|
|
if result.Thinking.Type != "adaptive" {
|
|
t.Errorf("expected thinking type 'adaptive' for Opus 4.7 effort-based, got %q", result.Thinking.Type)
|
|
}
|
|
if result.OutputConfig == nil || result.OutputConfig.Effort == nil {
|
|
t.Error("expected OutputConfig.Effort to be set for Opus 4.7 effort-based reasoning")
|
|
}
|
|
}
|