feat: implement claude api translation

Implement the API translation layer for the Claude provider.

This commit introduces the following changes:

1.  **Request Translation:** The  method in the
     now translates incoming OpenAI-formatted requests
    into the Claude API format. This includes handling differences in
    how system prompts are managed.

2.  **Response Translation:** The method also translates the response from
    the Claude API back into the OpenAI-compatible format, ensuring
    seamless integration with the rest of the system.

3.  **Data Structures:** The necessary structs for both OpenAI and Claude
    API formats are defined to facilitate the translation.

This change makes the Claude provider fully functional for non-streaming
chat completions, enabling true multi-provider support in the cache.

Author: messkan

internal/semantic/claude_provider.go

@@ -8,8 +8,36 @@ import (
 	"io"
 	"net/http"
 	"os"
+	"time"
 )
 
+// OpenAI-compatible structures for translation
+type OpenAIChatCompletionRequest struct {
+	Model    string          `json:"model"`
+	Messages []OpenAIMessage `json:"messages"`
+	Stream   bool            `json:"stream"`
+}
+
+type OpenAIMessage struct {
+	Role    string `json:"role"`
+	Content string `json:"content"`
+}
+
+type OpenAIChatCompletionResponse struct {
+	ID      string         `json:"id"`
+	Object  string         `json:"object"`
+	Created int64          `json:"created"`
+	Model   string         `json:"model"`
+	Choices []OpenAIChoice `json:"choices"`
+	Usage   any            `json:"usage"` // Keep it flexible
+}
+
+type OpenAIChoice struct {
+	Index        int           `json:"index"`
+	Message      OpenAIMessage `json:"message"`
+	FinishReason string        `json:"finish_reason"`
+}
+
 type ClaudeProvider struct {
 	apiKey string
 	client *http.Client
@@ -98,19 +126,119 @@ type ClaudeChatRequest struct {
 	MaxTokens int             `json:"max_tokens"`
 	System    string          `json:"system,omitempty"`
 	Messages  []ClaudeMessage `json:"messages"`
+	Stream    bool            `json:"stream"`
 }
 
 type ClaudeChatResponse struct {
-	Content []struct {
+	ID         string `json:"id"`
+	Model      string `json:"model"`
+	StopReason string `json:"stop_reason"`
+	Content    []struct {
 		Text string `json:"text"`
 	} `json:"content"`
+	Usage struct {
+		InputTokens  int `json:"input_tokens"`
+		OutputTokens int `json:"output_tokens"`
+	} `json:"usage"`
 }
 
 func (p *ClaudeProvider) ForwardChatCompletion(ctx context.Context, requestBody []byte) ([]byte, int, error) {
-	// Note: The Claude API is not 1:1 compatible with OpenAI's API.
-	// A translation layer is required to convert the request and response formats.
-	// This will be implemented in a subsequent step.
-	return nil, http.StatusNotImplemented, fmt.Errorf("chat completion for claude is not yet implemented")
+	// 1. Unmarshal the incoming OpenAI-compatible request
+	var openAIReq OpenAIChatCompletionRequest
+	if err := json.Unmarshal(requestBody, &openAIReq); err != nil {
+		return nil, http.StatusBadRequest, fmt.Errorf("failed to unmarshal request body: %w", err)
+	}
+
+	if openAIReq.Stream {
+		return nil, http.StatusNotImplemented, fmt.Errorf("streaming is not supported for claude provider yet")
+	}
+
+	// 2. Translate to Claude's request format
+	claudeReq := ClaudeChatRequest{
+		Model:     "claude-3-opus-20240229", // Or map from openAIReq.Model
+		MaxTokens: 1024,                    // Claude requires MaxTokens
+		Stream:    openAIReq.Stream,
+	}
+
+	// Separate system prompt from messages
+	var messages []ClaudeMessage
+	for _, msg := range openAIReq.Messages {
+		if msg.Role == "system" {
+			claudeReq.System = msg.Content
+		} else {
+			messages = append(messages, ClaudeMessage{
+				Role:    msg.Role,
+				Content: msg.Content,
+			})
+		}
+	}
+	claudeReq.Messages = messages
+
+	// 3. Marshal the new Claude request
+	claudeBody, err := json.Marshal(claudeReq)
+	if err != nil {
+		return nil, http.StatusInternalServerError, fmt.Errorf("failed to marshal claude request: %w", err)
+	}
+
+	// 4. Send the request to Claude's API
+	req, err := http.NewRequestWithContext(ctx, "POST", "https://api.anthropic.com/v1/messages", bytes.NewBuffer(claudeBody))
+	if err != nil {
+		return nil, http.StatusInternalServerError, err
+	}
+	req.Header.Set("Content-Type", "application/json")
+	req.Header.Set("x-api-key", p.apiKey)
+	req.Header.Set("anthropic-version", "2023-06-01")
+
+	resp, err := p.client.Do(req)
+	if err != nil {
+		return nil, http.StatusInternalServerError, err
+	}
+	defer resp.Body.Close()
+
+	claudeRespBody, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return nil, http.StatusInternalServerError, err
+	}
+
+	if resp.StatusCode != http.StatusOK {
+		return claudeRespBody, resp.StatusCode, fmt.Errorf("claude API error: %s", string(claudeRespBody))
+	}
+
+	// 5. Unmarshal Claude's response
+	var claudeResp ClaudeChatResponse
+	if err := json.Unmarshal(claudeRespBody, &claudeResp); err != nil {
+		return nil, http.StatusInternalServerError, fmt.Errorf("failed to unmarshal claude response: %w", err)
+	}
+
+	// 6. Translate back to OpenAI's response format
+	openAIResp := OpenAIChatCompletionResponse{
+		ID:      claudeResp.ID,
+		Object:  "chat.completion",
+		Created: time.Now().Unix(),
+		Model:   claudeResp.Model,
+		Usage:   claudeResp.Usage,
+	}
+
+	if len(claudeResp.Content) > 0 {
+		openAIResp.Choices = []OpenAIChoice{
+			{
+				Index: 0,
+				Message: OpenAIMessage{
+					Role:    "assistant",
+					Content: claudeResp.Content[0].Text,
+				},
+				FinishReason: claudeResp.StopReason,
+			},
+		}
+	}
+
+	// 7. Marshal the final OpenAI-compatible response
+	finalRespBody, err := json.Marshal(openAIResp)
+	if err != nil {
+		return nil, http.StatusInternalServerError, fmt.Errorf("failed to marshal final response: %w", err)
+	}
+
+	return finalRespBody, http.StatusOK, nil
 }
 
 func (p *ClaudeProvider) CheckSimilarity(ctx context.Context, prompt1, prompt2 string) (bool, error) {