init

Signed-off-by: yxia216 <[email protected]>

Author: hustxiayang

internal/apischema/openai/openai.go

@@ -10,6 +10,7 @@ package openai
 
 import (
 	"bytes"
+	"encoding/base64"
 	"encoding/json"
 	"errors"
 	"fmt"
@@ -515,8 +516,8 @@ type ChatCompletionAssistantMessageParamContent struct {
 	Text *string `json:"text,omitempty"`
 
 	// The signature for a thinking block.
-	Signature               *string `json:"signature,omitempty"`
-	RedactedContent         []byte  `json:"redactedContent,omitempty"`
+	Signature               *string               `json:"signature,omitempty"`
+	RedactedContent         *RedactedContentUnion `json:"redactedContent,omitempty"`
 	*AnthropicContentFields `json:",inline,omitempty"`
 }
 
@@ -1583,6 +1584,43 @@ func (e EmbeddingUnion) MarshalJSON() ([]byte, error) {
 	return json.Marshal(e.Value)
 }
 
+// RedactedContentUnion is a union type that can handle both []byte and string formats.
+// AWS Bedrock uses []byte while GCP Anthropic uses string.
+type RedactedContentUnion struct {
+	Value any
+}
+
+// UnmarshalJSON implements json.Unmarshaler to handle both []byte and string formats.
+func (r *RedactedContentUnion) UnmarshalJSON(data []byte) error {
+	// Try to unmarshal as []byte first (base64 encoded).
+	var str string
+	if err := json.Unmarshal(data, &str); err == nil {
+		// Try to decode as base64 first (this would be []byte encoded as base64)
+		if decoded, err := base64.StdEncoding.DecodeString(str); err == nil {
+			r.Value = decoded
+			return nil
+		}
+		// If not base64, treat as plain string
+		r.Value = str
+		return nil
+	}
+
+	return errors.New("redactedContent must be either []byte (base64 encoded) or string")
+}
+
+// MarshalJSON implements json.Marshaler.
+func (r RedactedContentUnion) MarshalJSON() ([]byte, error) {
+	switch v := r.Value.(type) {
+	case []byte:
+		// Encode []byte as base64 string
+		return json.Marshal(base64.StdEncoding.EncodeToString(v))
+	case string:
+		return json.Marshal(v)
+	default:
+		return json.Marshal(r.Value)
+	}
+}
+
 // EmbeddingUsage represents the usage information for an embeddings request.
 // https://platform.openai.com/docs/api-reference/embeddings/object#embeddings/object-usage
 type EmbeddingUsage struct {

internal/translator/openai_awsbedrock.go

@@ -312,11 +312,18 @@ func (o *openAIToAWSBedrockTranslatorV1ChatCompletion) openAIMessageToBedrockMes
 			}
 		case openai.ChatCompletionAssistantMessageParamContentTypeRedactedThinking:
 			if content.RedactedContent != nil {
-				contentBlocks = append(contentBlocks, &awsbedrock.ContentBlock{
-					ReasoningContent: &awsbedrock.ReasoningContentBlock{
-						RedactedContent: content.RedactedContent,
-					},
-				})
+				switch v := content.RedactedContent.Value.(type) {
+				case []byte:
+					contentBlocks = append(contentBlocks, &awsbedrock.ContentBlock{
+						ReasoningContent: &awsbedrock.ReasoningContentBlock{
+							RedactedContent: v,
+						},
+					})
+				case string:
+					return nil, fmt.Errorf("AWS Bedrock does not support string format for RedactedContent, expected []byte")
+				default:
+					return nil, fmt.Errorf("unsupported RedactedContent type: %T, expected []byte", v)
+				}
 			}
 		case openai.ChatCompletionAssistantMessageParamContentTypeRefusal:
 			if content.Refusal != nil {

internal/translator/openai_awsbedrock_test.go

@@ -986,7 +986,7 @@ func TestOpenAIToAWSBedrockTranslatorV1ChatCompletion_RequestBody(t *testing.T)
 								Value: []openai.ChatCompletionAssistantMessageParamContent{
 									{
 										Type:            openai.ChatCompletionAssistantMessageParamContentTypeRedactedThinking,
-										RedactedContent: []byte{104, 101, 108, 108, 111},
+										RedactedContent: &openai.RedactedContentUnion{Value: []byte{104, 101, 108, 108, 111}},
 									},
 								},
 							},

internal/translator/openai_gcpanthropic.go

@@ -375,29 +375,71 @@ func anthropicRoleToOpenAIRole(role anthropic.MessageParamRole) (string, error)
 	}
 }
 
+// processAssistantContent processes a single ChatCompletionAssistantMessageParamContent and returns the corresponding Anthropic content block.
+func processAssistantContent(content openai.ChatCompletionAssistantMessageParamContent) (*anthropic.ContentBlockParamUnion, error) {
+	switch content.Type {
+	case openai.ChatCompletionAssistantMessageParamContentTypeRefusal:
+		if content.Refusal != nil {
+			block := anthropic.NewTextBlock(*content.Refusal)
+			return &block, nil
+		}
+	case openai.ChatCompletionAssistantMessageParamContentTypeText:
+		if content.Text != nil {
+			textBlock := anthropic.NewTextBlock(*content.Text)
+			if isCacheEnabled(content.AnthropicContentFields) {
+				textBlock.OfText.CacheControl = content.CacheControl
+			}
+			return &textBlock, nil
+		}
+	case openai.ChatCompletionAssistantMessageParamContentTypeThinking:
+		// thinking can not be cached: https://platform.claude.com/docs/en/build-with-claude/prompt-caching
+		if content.Text != nil && content.Signature != nil {
+			thinkBlock := anthropic.NewThinkingBlock(*content.Text, *content.Signature)
+			return &thinkBlock, nil
+		}
+	case openai.ChatCompletionAssistantMessageParamContentTypeRedactedThinking:
+		if content.RedactedContent != nil {
+			switch v := content.RedactedContent.Value.(type) {
+			case string:
+				redactedThinkingBlock := anthropic.NewRedactedThinkingBlock(v)
+				return &redactedThinkingBlock, nil
+			case []byte:
+				return nil, fmt.Errorf("GCP Anthropic does not support []byte format for RedactedContent, expected string")
+			default:
+				return nil, fmt.Errorf("unsupported RedactedContent type: %T, expected string", v)
+			}
+		}
+	default:
+		return nil, fmt.Errorf("content type not supported: %v", content.Type)
+	}
+	return nil, nil
+}
+
 // openAIMessageToAnthropicMessageRoleAssistant converts an OpenAI assistant message to Anthropic content blocks.
 // The tool_use content is appended to the Anthropic message content list if tool_calls are present.
 func openAIMessageToAnthropicMessageRoleAssistant(openAiMessage *openai.ChatCompletionAssistantMessageParam) (anthropicMsg anthropic.MessageParam, err error) {
 	contentBlocks := make([]anthropic.ContentBlockParamUnion, 0)
 	if v, ok := openAiMessage.Content.Value.(string); ok && len(v) > 0 {
 		contentBlocks = append(contentBlocks, anthropic.NewTextBlock(v))
 	} else if content, ok := openAiMessage.Content.Value.(openai.ChatCompletionAssistantMessageParamContent); ok {
-		switch content.Type {
-		case openai.ChatCompletionAssistantMessageParamContentTypeRefusal:
-			if content.Refusal != nil {
-				contentBlocks = append(contentBlocks, anthropic.NewTextBlock(*content.Refusal))
-			}
-		case openai.ChatCompletionAssistantMessageParamContentTypeText:
-			if content.Text != nil {
-				textBlock := anthropic.NewTextBlock(*content.Text)
-				if isCacheEnabled(content.AnthropicContentFields) {
-					textBlock.OfText.CacheControl = content.CacheControl
-				}
-				contentBlocks = append(contentBlocks, textBlock)
+		// Handle single content object
+		var block *anthropic.ContentBlockParamUnion
+		block, err = processAssistantContent(content)
+		if err != nil {
+			return anthropicMsg, err
+		} else if block != nil {
+			contentBlocks = append(contentBlocks, *block)
+		}
+	} else if contents, ok := openAiMessage.Content.Value.([]openai.ChatCompletionAssistantMessageParamContent); ok {
+		// Handle array of content objects
+		for _, content := range contents {
+			var block *anthropic.ContentBlockParamUnion
+			block, err = processAssistantContent(content)
+			if err != nil {
+				return anthropicMsg, err
+			} else if block != nil {
+				contentBlocks = append(contentBlocks, *block)
 			}
-		default:
-			err = fmt.Errorf("content type not supported: %v", content.Type)
-			return
 		}
 	}