released the mock

llm.go

@@ -1,30 +1,112 @@
 package sidekick
 
 import (
-  "context"
+	"bytes"
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
 )
 
 // LLMClient represents an abstraction over the LLM provider
 type LLMClient interface {
-  Call(ctx context.Context, model ModelConfig, messages []Message, tools map[string]ToolDefinition) (Message, error)
+	Call(ctx context.Context, model ModelConfig, messages []Message, tools map[string]ToolDefinition) (Message, error)
 }
 
-var defaultLLMClient LLMClient = &mockLLMClient{}
+// standardLLMClient is an OpenAI-compatible implementation
+type standardLLMClient struct{}
+
+func (s *standardLLMClient) Call(ctx context.Context, model ModelConfig, msgs []Message, ts map[string]ToolDefinition) (Message, error) {
+	client := &http.Client{
+		Timeout: model.Timeout,
+	}
+
+	reqBody := map[string]interface{}{
+		"model":       model.ModelID,
+		"messages":    msgs,
+		"temperature": model.Temperature,
+	}
+	if model.MaxTokens > 0 {
+		reqBody["max_tokens"] = model.MaxTokens
+	}
+
+	if len(ts) > 0 {
+		var tools []map[string]interface{}
+		for _, t := range ts {
+			tools = append(tools, t.ConvertToOpenAITool())
+		}
+		reqBody["tools"] = tools
+	}
+
+	jsonBody, err := json.Marshal(reqBody)
+	if err != nil {
+		return Message{}, fmt.Errorf("failed to marshal request: %w", err)
+	}
+
+	req, err := http.NewRequestWithContext(ctx, "POST", model.Endpoint+"/chat/completions", bytes.NewBuffer(jsonBody))
+	if err != nil {
+		return Message{}, fmt.Errorf("failed to create request: %w", err)
+	}
+
+	req.Header.Set("Content-Type", "application/json")
+	req.Header.Set("Authorization", "Bearer "+model.APIKey)
+
+	resp, err := client.Do(req)
+	if err != nil {
+		return Message{}, fmt.Errorf("HTTP request failed: %w", err)
+	}
+	defer resp.Body.Close()
+
+	body, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return Message{}, fmt.Errorf("failed to read response body: %w", err)
+	}
+
+	if resp.StatusCode != http.StatusOK {
+		return Message{}, fmt.Errorf("API returned error (%d): %s", resp.StatusCode, string(body))
+	}
+
+	var openAIResp struct {
+		Choices []struct {
+			Message Message `json:"message"`
+		} `json:"choices"`
+		Error *struct {
+			Message string `json:"message"`
+		} `json:"error,omitempty"`
+	}
+
+	if err := json.Unmarshal(body, &openAIResp); err != nil {
+		return Message{}, fmt.Errorf("failed to unmarshal response: %w", err)
+	}
+
+	if openAIResp.Error != nil {
+		return Message{}, fmt.Errorf("API error: %s", openAIResp.Error.Message)
+	}
+
+	if len(openAIResp.Choices) == 0 {
+		return Message{}, fmt.Errorf("API returned no choices")
+	}
+
+	return openAIResp.Choices[0].Message, nil
+}
+
+var defaultLLMClient LLMClient = &standardLLMClient{}
 
 // SetLLMClient allows overriding the LLM client (e.g. for testing)
 func SetLLMClient(client LLMClient) {
-  defaultLLMClient = client
+	defaultLLMClient = client
 }
 
 // CallLLM invokes the configured LLM client
 func CallLLM(ctx context.Context, model ModelConfig, msgs []Message, tools map[string]ToolDefinition) (Message, error) {
-  return defaultLLMClient.Call(ctx, model, msgs, tools)
+	return defaultLLMClient.Call(ctx, model, msgs, tools)
 }
 
 // mockLLMClient is used as a fallback if no actual HTTP client is injected.
 type mockLLMClient struct {
-  responses []Message
-  calls     int
+	responses []Message
+	calls     int
 }
 
 func (m *mockLLMClient) Call(ctx context.Context, model ModelConfig, msgs []Message, ts map[string]ToolDefinition) (Message, error) {