refactor(lsp,llm,hexailsp,appconfig): split long funcs; add tests

- Extract helpers to keep funcs <=50 lines; no behavior changes
- Add tests for prompt removal, code actions, and LLM request builders
- Table-drive TestInParamList; run gofmt

6 files changed, 385 insertions, 331 deletions

diff --git a/internal/llm/copilot.go b/internal/llm/copilot.go
index 47ce11e..67cffc9 100644
--- a/internal/llm/copilot.go
+++ b/internal/llm/copilot.go
@@ -17,20 +17,20 @@ import (
 
 // copilotClient implements Client against GitHub Copilot's Chat Completions API.
 type copilotClient struct {
-    httpClient   *http.Client
-    apiKey       string
-    baseURL      string
-    defaultModel string
-    chatLogger   logging.ChatLogger
-    defaultTemperature *float64
+	httpClient         *http.Client
+	apiKey             string
+	baseURL            string
+	defaultModel       string
+	chatLogger         logging.ChatLogger
+	defaultTemperature *float64
 }
 
 type copilotChatRequest struct {
-    Model       string           `json:"model"`
-    Messages    []copilotMessage `json:"messages"`
-    Temperature *float64         `json:"temperature,omitempty"`
-    MaxTokens   *int             `json:"max_tokens,omitempty"`
-    Stop        []string         `json:"stop,omitempty"`
+	Model       string           `json:"model"`
+	Messages    []copilotMessage `json:"messages"`
+	Temperature *float64         `json:"temperature,omitempty"`
+	MaxTokens   *int             `json:"max_tokens,omitempty"`
+	Stop        []string         `json:"stop,omitempty"`
 }
 
 type copilotMessage struct {
@@ -57,20 +57,20 @@ type copilotChatResponse struct {
 
 // Constructor (kept among the first functions by convention)
 func newCopilot(baseURL, model, apiKey string, defaultTemp *float64) Client {
-    if strings.TrimSpace(baseURL) == "" {
-        baseURL = "https://api.githubcopilot.com"
-    }
-    if strings.TrimSpace(model) == "" {
-        model = "gpt-4.1"
-    }
-    return copilotClient{
-        httpClient:   &http.Client{Timeout: 30 * time.Second},
-        apiKey:       apiKey,
-        baseURL:      strings.TrimRight(baseURL, "/"),
-        defaultModel: model,
-        chatLogger:   logging.NewChatLogger("copilot"),
-        defaultTemperature: defaultTemp,
-    }
+	if strings.TrimSpace(baseURL) == "" {
+		baseURL = "https://api.githubcopilot.com"
+	}
+	if strings.TrimSpace(model) == "" {
+		model = "gpt-4.1"
+	}
+	return copilotClient{
+		httpClient:         &http.Client{Timeout: 30 * time.Second},
+		apiKey:             apiKey,
+		baseURL:            strings.TrimRight(baseURL, "/"),
+		defaultModel:       model,
+		chatLogger:         logging.NewChatLogger("copilot"),
+		defaultTemperature: defaultTemp,
+	}
 }
 
 func (c copilotClient) Chat(ctx context.Context, messages []Message, opts ...RequestOption) (string, error) {
@@ -84,38 +84,14 @@ func (c copilotClient) Chat(ctx context.Context, messages []Message, opts ...Req
 	if o.Model == "" {
 		o.Model = c.defaultModel
 	}
-
 	start := time.Now()
-	logMessages := make([]struct {
-		Role    string
-		Content string
-	}, len(messages))
+	logMessages := make([]struct{ Role, Content string }, len(messages))
 	for i, m := range messages {
-		logMessages[i] = struct {
-			Role    string
-			Content string
-		}{Role: m.Role, Content: m.Content}
+		logMessages[i] = struct{ Role, Content string }{m.Role, m.Content}
 	}
 	c.chatLogger.LogStart(false, o.Model, o.Temperature, o.MaxTokens, o.Stop, logMessages)
 
-	req := copilotChatRequest{Model: o.Model}
-	req.Messages = make([]copilotMessage, len(messages))
-	for i, m := range messages {
-		req.Messages[i] = copilotMessage{Role: m.Role, Content: m.Content}
-	}
-    if o.Temperature != 0 {
-        req.Temperature = &o.Temperature
-    } else if c.defaultTemperature != nil {
-        t := *c.defaultTemperature
-        req.Temperature = &t
-    }
-	if o.MaxTokens > 0 {
-		req.MaxTokens = &o.MaxTokens
-	}
-	if len(o.Stop) > 0 {
-		req.Stop = o.Stop
-	}
-
+	req := buildCopilotChatRequest(o, messages, c.defaultTemperature)
 	body, err := json.Marshal(req)
 	if err != nil {
 		logging.Logf("llm/copilot ", "marshal error: %v", err)
@@ -124,34 +100,19 @@ func (c copilotClient) Chat(ctx context.Context, messages []Message, opts ...Req
 
 	endpoint := c.baseURL + "/chat/completions"
 	logging.Logf("llm/copilot ", "POST %s", endpoint)
-	httpReq, err := http.NewRequestWithContext(ctx, http.MethodPost, endpoint, bytes.NewReader(body))
-	if err != nil {
-		logging.Logf("llm/copilot ", "new request error: %v", err)
-		return "", err
-	}
-	httpReq.Header.Set("Content-Type", "application/json")
-	httpReq.Header.Set("Authorization", "Bearer "+c.apiKey)
-
-	resp, err := c.httpClient.Do(httpReq)
+	resp, err := c.doJSON(ctx, endpoint, body, map[string]string{
+		"Authorization": "Bearer " + c.apiKey,
+	})
 	if err != nil {
 		logging.Logf("llm/copilot ", "%shttp error after %s: %v%s", logging.AnsiRed, time.Since(start), err, logging.AnsiBase)
 		return "", err
 	}
 	defer resp.Body.Close()
-	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
-		var apiErr copilotChatResponse
-		_ = json.NewDecoder(resp.Body).Decode(&apiErr)
-		if apiErr.Error != nil && strings.TrimSpace(apiErr.Error.Message) != "" {
-			logging.Logf("llm/copilot ", "%sapi error status=%d type=%s msg=%s duration=%s%s", logging.AnsiRed, resp.StatusCode, apiErr.Error.Type, apiErr.Error.Message, time.Since(start), logging.AnsiBase)
-			return "", fmt.Errorf("copilot error: %s (status %d)", apiErr.Error.Message, resp.StatusCode)
-		}
-		logging.Logf("llm/copilot ", "%shttp non-2xx status=%d duration=%s%s", logging.AnsiRed, resp.StatusCode, time.Since(start), logging.AnsiBase)
-		return "", fmt.Errorf("copilot http error: status %d", resp.StatusCode)
+	if err := handleCopilotNon2xx(resp, start); err != nil {
+		return "", err
 	}
-
-	var out copilotChatResponse
-	if err := json.NewDecoder(resp.Body).Decode(&out); err != nil {
-		logging.Logf("llm/copilot ", "%sdecode error after %s: %v%s", logging.AnsiRed, time.Since(start), err, logging.AnsiBase)
+	out, err := decodeCopilotChat(resp, start)
+	if err != nil {
 		return "", err
 	}
 	if len(out.Choices) == 0 {
@@ -166,3 +127,60 @@ func (c copilotClient) Chat(ctx context.Context, messages []Message, opts ...Req
 // Provider metadata
 func (c copilotClient) Name() string         { return "copilot" }
 func (c copilotClient) DefaultModel() string { return c.defaultModel }
+
+// helpers
+func buildCopilotChatRequest(o Options, messages []Message, defaultTemp *float64) copilotChatRequest {
+	req := copilotChatRequest{Model: o.Model}
+	req.Messages = make([]copilotMessage, len(messages))
+	for i, m := range messages {
+		req.Messages[i] = copilotMessage{Role: m.Role, Content: m.Content}
+	}
+	if o.Temperature != 0 {
+		req.Temperature = &o.Temperature
+	} else if defaultTemp != nil {
+		t := *defaultTemp
+		req.Temperature = &t
+	}
+	if o.MaxTokens > 0 {
+		req.MaxTokens = &o.MaxTokens
+	}
+	if len(o.Stop) > 0 {
+		req.Stop = o.Stop
+	}
+	return req
+}
+
+func (c copilotClient) doJSON(ctx context.Context, url string, body []byte, headers map[string]string) (*http.Response, error) {
+	req, err := http.NewRequestWithContext(ctx, http.MethodPost, url, bytes.NewReader(body))
+	if err != nil {
+		return nil, err
+	}
+	req.Header.Set("Content-Type", "application/json")
+	for k, v := range headers {
+		req.Header.Set(k, v)
+	}
+	return c.httpClient.Do(req)
+}
+
+func handleCopilotNon2xx(resp *http.Response, start time.Time) error {
+	if resp.StatusCode >= 200 && resp.StatusCode < 300 {
+		return nil
+	}
+	var apiErr copilotChatResponse
+	_ = json.NewDecoder(resp.Body).Decode(&apiErr)
+	if apiErr.Error != nil && strings.TrimSpace(apiErr.Error.Message) != "" {
+		logging.Logf("llm/copilot ", "%sapi error status=%d type=%s msg=%s duration=%s%s", logging.AnsiRed, resp.StatusCode, apiErr.Error.Type, apiErr.Error.Message, time.Since(start), logging.AnsiBase)
+		return fmt.Errorf("copilot error: %s (status %d)", apiErr.Error.Message, resp.StatusCode)
+	}
+	logging.Logf("llm/copilot ", "%shttp non-2xx status=%d duration=%s%s", logging.AnsiRed, resp.StatusCode, time.Since(start), logging.AnsiBase)
+	return fmt.Errorf("copilot http error: status %d", resp.StatusCode)
+}
+
+func decodeCopilotChat(resp *http.Response, start time.Time) (copilotChatResponse, error) {
+	var out copilotChatResponse
+	if err := json.NewDecoder(resp.Body).Decode(&out); err != nil {
+		logging.Logf("llm/copilot ", "%sdecode error after %s: %v%s", logging.AnsiRed, time.Since(start), err, logging.AnsiBase)
+		return copilotChatResponse{}, err
+	}
+	return out, nil
+}
diff --git a/internal/llm/copilot_test.go b/internal/llm/copilot_test.go
new file mode 100644
index 0000000..5492713
--- /dev/null
+++ b/internal/llm/copilot_test.go
@@ -0,0 +1,15 @@
+package llm
+
+import "testing"
+
+func TestBuildCopilotChatRequest_FieldsAndDefaults(t *testing.T) {
+    o := Options{Model: "gpt-x", Temperature: 0, MaxTokens: 123, Stop: []string{"X"}}
+    msgs := []Message{{Role: "user", Content: "q"}}
+    req := buildCopilotChatRequest(o, msgs, f64p(0.5))
+    if req.Model != "gpt-x" { t.Fatalf("model mismatch: %q", req.Model) }
+    if req.Temperature == nil || *req.Temperature != 0.5 { t.Fatalf("default temp not applied") }
+    if req.MaxTokens == nil || *req.MaxTokens != 123 { t.Fatalf("max_tokens not applied") }
+    if len(req.Stop) != 1 || req.Stop[0] != "X" { t.Fatalf("stop not applied") }
+    if len(req.Messages) != 1 || req.Messages[0].Content != "q" { t.Fatalf("messages not copied") }
+}
+
diff --git a/internal/llm/ollama.go b/internal/llm/ollama.go
index 20dfe2a..50e9837 100644
--- a/internal/llm/ollama.go
+++ b/internal/llm/ollama.go
@@ -1,5 +1,4 @@
 // Summary: Ollama client against a local server; supports chat responses and streaming via /api/chat.
-// Not yet reviewed by a human
 package llm
 
 import (
@@ -18,11 +17,11 @@ import (
 
 // ollamaClient implements Client against a local Ollama server.
 type ollamaClient struct {
-    httpClient   *http.Client
-    baseURL      string
-    defaultModel string
-    chatLogger   logging.ChatLogger
-    defaultTemperature *float64
+	httpClient         *http.Client
+	baseURL            string
+	defaultModel       string
+	chatLogger         logging.ChatLogger
+	defaultTemperature *float64
 }
 
 type ollamaChatRequest struct {
@@ -49,13 +48,13 @@ func newOllama(baseURL, model string, defaultTemp *float64) Client {
 	if strings.TrimSpace(model) == "" {
 		model = "qwen3-coder:30b-a3b-q4_K_M`"
 	}
-    return ollamaClient{
-        httpClient:   &http.Client{Timeout: 30 * time.Second},
-        baseURL:      strings.TrimRight(baseURL, "/"),
-        defaultModel: model,
-        chatLogger:   logging.NewChatLogger("ollama"),
-        defaultTemperature: defaultTemp,
-    }
+	return ollamaClient{
+		httpClient:         &http.Client{Timeout: 30 * time.Second},
+		baseURL:            strings.TrimRight(baseURL, "/"),
+		defaultModel:       model,
+		chatLogger:         logging.NewChatLogger("ollama"),
+		defaultTemperature: defaultTemp,
+	}
 }
 
 // TODO: This function is too long and should be refactored for readability and maintainability.
@@ -69,41 +68,8 @@ func (c ollamaClient) Chat(ctx context.Context, messages []Message, opts ...Requ
 	}
 
 	start := time.Now()
-	logMessages := make([]struct {
-		Role    string
-		Content string
-	}, len(messages))
-	for i, m := range messages {
-		logMessages[i] = struct {
-			Role    string
-			Content string
-		}{Role: m.Role, Content: m.Content}
-	}
-	c.chatLogger.LogStart(false, o.Model, o.Temperature, o.MaxTokens, o.Stop, logMessages)
-
-	req := ollamaChatRequest{Model: o.Model, Stream: false}
-	req.Messages = make([]oaMessage, len(messages))
-	for i, m := range messages {
-		req.Messages[i] = oaMessage{Role: m.Role, Content: m.Content}
-	}
-
-	// Build options map only if any option is set
-	optsMap := map[string]any{}
-    if o.Temperature != 0 {
-        optsMap["temperature"] = o.Temperature
-    } else if c.defaultTemperature != nil {
-        optsMap["temperature"] = *c.defaultTemperature
-    }
-	if o.MaxTokens > 0 {
-		optsMap["num_predict"] = o.MaxTokens
-	}
-	if len(o.Stop) > 0 {
-		optsMap["stop"] = o.Stop
-	}
-	if len(optsMap) > 0 {
-		req.Options = optsMap
-	}
-
+	c.logStart(false, o, messages)
+	req := buildOllamaRequest(o, messages, c.defaultTemperature, false)
 	body, err := json.Marshal(req)
 	if err != nil {
 		return "", err
@@ -111,27 +77,14 @@ func (c ollamaClient) Chat(ctx context.Context, messages []Message, opts ...Requ
 
 	endpoint := c.baseURL + "/api/chat"
 	logging.Logf("llm/ollama ", "POST %s", endpoint)
-	httpReq, err := http.NewRequestWithContext(ctx, http.MethodPost, endpoint, bytes.NewReader(body))
-	if err != nil {
-		return "", err
-	}
-	httpReq.Header.Set("Content-Type", "application/json")
-
-	resp, err := c.httpClient.Do(httpReq)
+	resp, err := c.doJSON(ctx, endpoint, body)
 	if err != nil {
 		logging.Logf("llm/ollama ", "%shttp error after %s: %v%s", logging.AnsiRed, time.Since(start), err, logging.AnsiBase)
 		return "", err
 	}
 	defer resp.Body.Close()
-	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
-		var apiErr ollamaChatResponse
-		_ = json.NewDecoder(resp.Body).Decode(&apiErr)
-		if strings.TrimSpace(apiErr.Error) != "" {
-			logging.Logf("llm/ollama ", "%sapi error status=%d msg=%s duration=%s%s", logging.AnsiRed, resp.StatusCode, apiErr.Error, time.Since(start), logging.AnsiBase)
-			return "", fmt.Errorf("ollama error: %s (status %d)", apiErr.Error, resp.StatusCode)
-		}
-		logging.Logf("llm/ollama ", "%shttp non-2xx status=%d duration=%s%s", logging.AnsiRed, resp.StatusCode, time.Since(start), logging.AnsiBase)
-		return "", fmt.Errorf("ollama http error: status %d", resp.StatusCode)
+	if err := handleOllamaNon2xx(resp, start); err != nil {
+		return "", err
 	}
 
 	var out ollamaChatResponse
@@ -163,40 +116,8 @@ func (c ollamaClient) ChatStream(ctx context.Context, messages []Message, onDelt
 	}
 
 	start := time.Now()
-	logMessages := make([]struct {
-		Role    string
-		Content string
-	}, len(messages))
-	for i, m := range messages {
-		logMessages[i] = struct {
-			Role    string
-			Content string
-		}{Role: m.Role, Content: m.Content}
-	}
-	c.chatLogger.LogStart(true, o.Model, o.Temperature, o.MaxTokens, o.Stop, logMessages)
-
-	req := ollamaChatRequest{Model: o.Model, Stream: true}
-	req.Messages = make([]oaMessage, len(messages))
-	for i, m := range messages {
-		req.Messages[i] = oaMessage{Role: m.Role, Content: m.Content}
-	}
-	// Build options map
-	optsMap := map[string]any{}
-    if o.Temperature != 0 {
-        optsMap["temperature"] = o.Temperature
-    } else if c.defaultTemperature != nil {
-        optsMap["temperature"] = *c.defaultTemperature
-    }
-	if o.MaxTokens > 0 {
-		optsMap["num_predict"] = o.MaxTokens
-	}
-	if len(o.Stop) > 0 {
-		optsMap["stop"] = o.Stop
-	}
-	if len(optsMap) > 0 {
-		req.Options = optsMap
-	}
-
+	c.logStart(true, o, messages)
+	req := buildOllamaRequest(o, messages, c.defaultTemperature, true)
 	body, err := json.Marshal(req)
 	if err != nil {
 		return err
@@ -204,27 +125,14 @@ func (c ollamaClient) ChatStream(ctx context.Context, messages []Message, onDelt
 
 	endpoint := c.baseURL + "/api/chat"
 	logging.Logf("llm/ollama ", "POST %s (stream)", endpoint)
-	httpReq, err := http.NewRequestWithContext(ctx, http.MethodPost, endpoint, bytes.NewReader(body))
-	if err != nil {
-		return err
-	}
-	httpReq.Header.Set("Content-Type", "application/json")
-
-	resp, err := c.httpClient.Do(httpReq)
+	resp, err := c.doJSON(ctx, endpoint, body)
 	if err != nil {
 		logging.Logf("llm/ollama ", "%shttp error after %s: %v%s", logging.AnsiRed, time.Since(start), err, logging.AnsiBase)
 		return err
 	}
 	defer resp.Body.Close()
-	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
-		var apiErr ollamaChatResponse
-		_ = json.NewDecoder(resp.Body).Decode(&apiErr)
-		if strings.TrimSpace(apiErr.Error) != "" {
-			logging.Logf("llm/ollama ", "%sapi error status=%d msg=%s duration=%s%s", logging.AnsiRed, resp.StatusCode, apiErr.Error, time.Since(start), logging.AnsiBase)
-			return fmt.Errorf("ollama error: %s (status %d)", apiErr.Error, resp.StatusCode)
-		}
-		logging.Logf("llm/ollama ", "%shttp non-2xx status=%d duration=%s%s", logging.AnsiRed, resp.StatusCode, time.Since(start), logging.AnsiBase)
-		return fmt.Errorf("ollama http error: status %d", resp.StatusCode)
+	if err := handleOllamaNon2xx(resp, start); err != nil {
+		return err
 	}
 
 	dec := json.NewDecoder(resp.Body)
@@ -251,3 +159,59 @@ func (c ollamaClient) ChatStream(ctx context.Context, messages []Message, onDelt
 	logging.Logf("llm/ollama ", "stream end duration=%s", time.Since(start))
 	return nil
 }
+
+// helpers to keep methods small
+func (c ollamaClient) logStart(stream bool, o Options, messages []Message) {
+	logMessages := make([]struct{ Role, Content string }, len(messages))
+	for i, m := range messages {
+		logMessages[i] = struct{ Role, Content string }{m.Role, m.Content}
+	}
+	c.chatLogger.LogStart(stream, o.Model, o.Temperature, o.MaxTokens, o.Stop, logMessages)
+}
+
+func buildOllamaRequest(o Options, messages []Message, defaultTemp *float64, stream bool) ollamaChatRequest {
+	req := ollamaChatRequest{Model: o.Model, Stream: stream}
+	req.Messages = make([]oaMessage, len(messages))
+	for i, m := range messages {
+		req.Messages[i] = oaMessage{Role: m.Role, Content: m.Content}
+	}
+	optsMap := map[string]any{}
+	if o.Temperature != 0 {
+		optsMap["temperature"] = o.Temperature
+	} else if defaultTemp != nil {
+		optsMap["temperature"] = *defaultTemp
+	}
+	if o.MaxTokens > 0 {
+		optsMap["num_predict"] = o.MaxTokens
+	}
+	if len(o.Stop) > 0 {
+		optsMap["stop"] = o.Stop
+	}
+	if len(optsMap) > 0 {
+		req.Options = optsMap
+	}
+	return req
+}
+
+func (c ollamaClient) doJSON(ctx context.Context, url string, body []byte) (*http.Response, error) {
+	req, err := http.NewRequestWithContext(ctx, http.MethodPost, url, bytes.NewReader(body))
+	if err != nil {
+		return nil, err
+	}
+	req.Header.Set("Content-Type", "application/json")
+	return c.httpClient.Do(req)
+}
+
+func handleOllamaNon2xx(resp *http.Response, start time.Time) error {
+	if resp.StatusCode >= 200 && resp.StatusCode < 300 {
+		return nil
+	}
+	var apiErr ollamaChatResponse
+	_ = json.NewDecoder(resp.Body).Decode(&apiErr)
+	if strings.TrimSpace(apiErr.Error) != "" {
+		logging.Logf("llm/ollama ", "%sapi error status=%d msg=%s duration=%s%s", logging.AnsiRed, resp.StatusCode, apiErr.Error, time.Since(start), logging.AnsiBase)
+		return fmt.Errorf("ollama error: %s (status %d)", apiErr.Error, resp.StatusCode)
+	}
+	logging.Logf("llm/ollama ", "%shttp non-2xx status=%d duration=%s%s", logging.AnsiRed, resp.StatusCode, time.Since(start), logging.AnsiBase)
+	return fmt.Errorf("ollama http error: status %d", resp.StatusCode)
+}
diff --git a/internal/llm/ollama_test.go b/internal/llm/ollama_test.go
new file mode 100644
index 0000000..4ad6fdf
--- /dev/null
+++ b/internal/llm/ollama_test.go
@@ -0,0 +1,18 @@
+package llm
+
+import "testing"
+
+func TestBuildOllamaRequest_OptionsAndStream(t *testing.T) {
+    o := Options{Model: "codemodel", Temperature: 0, MaxTokens: 256, Stop: []string{"STOP"}}
+    msgs := []Message{{Role: "user", Content: "hello"}}
+    req := buildOllamaRequest(o, msgs, f64p(0.2), false)
+    if req.Model != "codemodel" || req.Stream { t.Fatalf("model/stream mismatch: %+v", req) }
+    if req.Options == nil { t.Fatalf("expected options map") }
+    if req.Options.(map[string]any)["temperature"].(float64) != 0.2 { t.Fatalf("default temp not applied") }
+    if req.Options.(map[string]any)["num_predict"].(int) != 256 { t.Fatalf("num_predict not applied") }
+    if req.Options.(map[string]any)["stop"].([]string)[0] != "STOP" { t.Fatalf("stop not applied") }
+
+    req2 := buildOllamaRequest(o, msgs, f64p(0.2), true)
+    if !req2.Stream { t.Fatalf("expected stream=true") }
+}
+
diff --git a/internal/llm/openai.go b/internal/llm/openai.go
index 5348def..69c0cfc 100644
--- a/internal/llm/openai.go
+++ b/internal/llm/openai.go
@@ -13,26 +13,26 @@ import (
 	"strings"
 	"time"
 
-    "hexai/internal/logging"
+	"hexai/internal/logging"
 )
 
 // openAIClient implements Client against OpenAI's Chat Completions API.
 type openAIClient struct {
-    httpClient   *http.Client
-    apiKey       string
-    baseURL      string
-    defaultModel string
-    chatLogger   logging.ChatLogger
-    defaultTemperature *float64
+	httpClient         *http.Client
+	apiKey             string
+	baseURL            string
+	defaultModel       string
+	chatLogger         logging.ChatLogger
+	defaultTemperature *float64
 }
 
 type oaChatRequest struct {
-    Model       string      `json:"model"`
-    Messages    []oaMessage `json:"messages"`
-    Temperature *float64    `json:"temperature,omitempty"`
-    MaxTokens   *int        `json:"max_tokens,omitempty"`
-    Stop        []string    `json:"stop,omitempty"`
-    Stream      bool        `json:"stream,omitempty"`
+	Model       string      `json:"model"`
+	Messages    []oaMessage `json:"messages"`
+	Temperature *float64    `json:"temperature,omitempty"`
+	MaxTokens   *int        `json:"max_tokens,omitempty"`
+	Stop        []string    `json:"stop,omitempty"`
+	Stream      bool        `json:"stream,omitempty"`
 }
 
 type oaMessage struct {
@@ -54,43 +54,43 @@ type oaChatResponse struct {
 		Type    string `json:"type"`
 		Param   any    `json:"param"`
 		Code    any    `json:"code"`
-    } `json:"error,omitempty"`
+	} `json:"error,omitempty"`
 }
 
 // Streaming response chunk type (SSE)
 type oaStreamChunk struct {
-    Choices []struct {
-        Delta struct {
-            Content string `json:"content"`
-        } `json:"delta"`
-        FinishReason string `json:"finish_reason"`
-    } `json:"choices"`
-    Error *struct {
-        Message string `json:"message"`
-        Type    string `json:"type"`
-        Param   any    `json:"param"`
-        Code    any    `json:"code"`
-    } `json:"error,omitempty"`
+	Choices []struct {
+		Delta struct {
+			Content string `json:"content"`
+		} `json:"delta"`
+		FinishReason string `json:"finish_reason"`
+	} `json:"choices"`
+	Error *struct {
+		Message string `json:"message"`
+		Type    string `json:"type"`
+		Param   any    `json:"param"`
+		Code    any    `json:"code"`
+	} `json:"error,omitempty"`
 }
 
 // Constructor (kept among the first functions by convention)
 // newOpenAI constructs an OpenAI client using explicit configuration values.
 // The apiKey may be empty; calls will fail until a valid key is supplied.
 func newOpenAI(baseURL, model, apiKey string, defaultTemp *float64) Client {
-    if strings.TrimSpace(baseURL) == "" {
-        baseURL = "https://api.openai.com/v1"
-    }
-    if strings.TrimSpace(model) == "" {
-        model = "gpt-4.1"
-    }
-    return openAIClient{
-        httpClient:   &http.Client{Timeout: 30 * time.Second},
-        apiKey:       apiKey,
-        baseURL:      baseURL,
-        defaultModel: model,
-        chatLogger:   logging.NewChatLogger("openai"),
-        defaultTemperature: defaultTemp,
-    }
+	if strings.TrimSpace(baseURL) == "" {
+		baseURL = "https://api.openai.com/v1"
+	}
+	if strings.TrimSpace(model) == "" {
+		model = "gpt-4.1"
+	}
+	return openAIClient{
+		httpClient:         &http.Client{Timeout: 30 * time.Second},
+		apiKey:             apiKey,
+		baseURL:            baseURL,
+		defaultModel:       model,
+		chatLogger:         logging.NewChatLogger("openai"),
+		defaultTemperature: defaultTemp,
+	}
 }
 
 func (c openAIClient) Chat(ctx context.Context, messages []Message, opts ...RequestOption) (string, error) {
@@ -105,37 +105,8 @@ func (c openAIClient) Chat(ctx context.Context, messages []Message, opts ...Requ
 		o.Model = c.defaultModel
 	}
 	start := time.Now()
-	logMessages := make([]struct {
-		Role    string
-		Content string
-	}, len(messages))
-	for i, m := range messages {
-		logMessages[i] = struct {
-			Role    string
-			Content string
-		}{Role: m.Role, Content: m.Content}
-	}
-	c.chatLogger.LogStart(false, o.Model, o.Temperature, o.MaxTokens, o.Stop, logMessages)
-
-	req := oaChatRequest{Model: o.Model}
-	req.Messages = make([]oaMessage, len(messages))
-	for i, m := range messages {
-		req.Messages[i] = oaMessage{Role: m.Role, Content: m.Content}
-	}
-    // Decide temperature: request option overrides config default.
-    if o.Temperature != 0 {
-        req.Temperature = &o.Temperature
-    } else if c.defaultTemperature != nil {
-        t := *c.defaultTemperature
-        req.Temperature = &t
-    }
-	if o.MaxTokens > 0 {
-		req.MaxTokens = &o.MaxTokens
-	}
-	if len(o.Stop) > 0 {
-		req.Stop = o.Stop
-	}
-
+	c.logStart(false, o, messages)
+	req := buildOAChatRequest(o, messages, c.defaultTemperature, false)
 	body, err := json.Marshal(req)
 	if err != nil {
 		c.logf("marshal error: %v", err)
@@ -143,33 +114,19 @@ func (c openAIClient) Chat(ctx context.Context, messages []Message, opts ...Requ
 	}
 	endpoint := c.baseURL + "/chat/completions"
 	logging.Logf("llm/openai ", "POST %s", endpoint)
-	httpReq, err := http.NewRequestWithContext(ctx, http.MethodPost, endpoint, bytes.NewReader(body))
-	if err != nil {
-		c.logf("new request error: %v", err)
-		return "", err
-	}
-	httpReq.Header.Set("Content-Type", "application/json")
-	httpReq.Header.Set("Authorization", "Bearer "+c.apiKey)
-
-	resp, err := c.httpClient.Do(httpReq)
+	resp, err := c.doJSON(ctx, endpoint, body, map[string]string{
+		"Authorization": "Bearer " + c.apiKey,
+	})
 	if err != nil {
 		logging.Logf("llm/openai ", "%shttp error after %s: %v%s", logging.AnsiRed, time.Since(start), err, logging.AnsiBase)
 		return "", err
 	}
 	defer resp.Body.Close()
-	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
-		var apiErr oaChatResponse
-		_ = json.NewDecoder(resp.Body).Decode(&apiErr)
-		if apiErr.Error != nil && apiErr.Error.Message != "" {
-			logging.Logf("llm/openai ", "%sapi error status=%d type=%s msg=%s duration=%s%s", logging.AnsiRed, resp.StatusCode, apiErr.Error.Type, apiErr.Error.Message, time.Since(start), logging.AnsiBase)
-			return "", fmt.Errorf("openai error: %s (status %d)", apiErr.Error.Message, resp.StatusCode)
-		}
-		logging.Logf("llm/openai ", "%shttp non-2xx status=%d duration=%s%s", logging.AnsiRed, resp.StatusCode, time.Since(start), logging.AnsiBase)
-		return "", fmt.Errorf("openai http error: status %d", resp.StatusCode)
+	if err := handleOpenAINon2xx(resp, start); err != nil {
+		return "", err
 	}
-	var out oaChatResponse
-	if err := json.NewDecoder(resp.Body).Decode(&out); err != nil {
-		logging.Logf("llm/openai ", "%sdecode error after %s: %v%s", logging.AnsiRed, time.Since(start), err, logging.AnsiBase)
+	out, err := decodeOpenAIChat(resp, start)
+	if err != nil {
 		return "", err
 	}
 	if len(out.Choices) == 0 {
@@ -177,7 +134,6 @@ func (c openAIClient) Chat(ctx context.Context, messages []Message, opts ...Requ
 		return "", errors.New("openai: no choices returned")
 	}
 	content := out.Choices[0].Message.Content
-	// Received context (green)
 	logging.Logf("llm/openai ", "success choice=0 finish=%s size=%d preview=%s%s%s duration=%s", out.Choices[0].FinishReason, len(content), logging.AnsiGreen, logging.PreviewForLog(content), logging.AnsiBase, time.Since(start))
 	return content, nil
 }
@@ -187,7 +143,6 @@ func (c openAIClient) Name() string         { return "openai" }
 func (c openAIClient) DefaultModel() string { return c.defaultModel }
 
 // Streaming support (optional)
- 
 
 func (c openAIClient) ChatStream(ctx context.Context, messages []Message, onDelta func(string), opts ...RequestOption) error {
 	if c.apiKey == "" {
@@ -201,74 +156,118 @@ func (c openAIClient) ChatStream(ctx context.Context, messages []Message, onDelt
 		o.Model = c.defaultModel
 	}
 	start := time.Now()
-	logMessages := make([]struct {
-		Role    string
-		Content string
-	}, len(messages))
+	c.logStart(true, o, messages)
+	req := buildOAChatRequest(o, messages, c.defaultTemperature, true)
+	body, err := json.Marshal(req)
+	if err != nil {
+		c.logf("marshal error: %v", err)
+		return err
+	}
+	endpoint := c.baseURL + "/chat/completions"
+	logging.Logf("llm/openai ", "POST %s (stream)", endpoint)
+	resp, err := c.doJSONWithAccept(ctx, endpoint, body, map[string]string{
+		"Authorization": "Bearer " + c.apiKey,
+	}, "text/event-stream")
+	if err != nil {
+		logging.Logf("llm/openai ", "%shttp error after %s: %v%s", logging.AnsiRed, time.Since(start), err, logging.AnsiBase)
+		return err
+	}
+	defer resp.Body.Close()
+	if err := handleOpenAINon2xx(resp, start); err != nil {
+		return err
+	}
+
+	if err := parseOpenAIStream(resp, start, onDelta); err != nil {
+		return err
+	}
+	logging.Logf("llm/openai ", "stream end duration=%s", time.Since(start))
+	return nil
+}
+
+// Private helpers
+func (c openAIClient) logf(format string, args ...any) { logging.Logf("llm/openai ", format, args...) }
+
+// helpers extracted to keep methods small
+func (c openAIClient) logStart(stream bool, o Options, messages []Message) {
+	logMessages := make([]struct{ Role, Content string }, len(messages))
 	for i, m := range messages {
-		logMessages[i] = struct {
-			Role    string
-			Content string
-		}{Role: m.Role, Content: m.Content}
+		logMessages[i] = struct{ Role, Content string }{m.Role, m.Content}
 	}
-	c.chatLogger.LogStart(true, o.Model, o.Temperature, o.MaxTokens, o.Stop, logMessages)
+	c.chatLogger.LogStart(stream, o.Model, o.Temperature, o.MaxTokens, o.Stop, logMessages)
+}
 
-	req := oaChatRequest{Model: o.Model, Stream: true}
+func buildOAChatRequest(o Options, messages []Message, defaultTemp *float64, stream bool) oaChatRequest {
+	req := oaChatRequest{Model: o.Model, Stream: stream}
 	req.Messages = make([]oaMessage, len(messages))
 	for i, m := range messages {
 		req.Messages[i] = oaMessage{Role: m.Role, Content: m.Content}
 	}
-    if o.Temperature != 0 {
-        req.Temperature = &o.Temperature
-    } else if c.defaultTemperature != nil {
-        t := *c.defaultTemperature
-        req.Temperature = &t
-    }
+	if o.Temperature != 0 {
+		req.Temperature = &o.Temperature
+	} else if defaultTemp != nil {
+		t := *defaultTemp
+		req.Temperature = &t
+	}
 	if o.MaxTokens > 0 {
 		req.MaxTokens = &o.MaxTokens
 	}
 	if len(o.Stop) > 0 {
 		req.Stop = o.Stop
 	}
+	return req
+}
 
-	body, err := json.Marshal(req)
+func (c openAIClient) doJSON(ctx context.Context, url string, body []byte, headers map[string]string) (*http.Response, error) {
+	req, err := http.NewRequestWithContext(ctx, http.MethodPost, url, bytes.NewReader(body))
 	if err != nil {
-		c.logf("marshal error: %v", err)
-		return err
+		return nil, err
 	}
-	endpoint := c.baseURL + "/chat/completions"
-	logging.Logf("llm/openai ", "POST %s (stream)", endpoint)
-	httpReq, err := http.NewRequestWithContext(ctx, http.MethodPost, endpoint, bytes.NewReader(body))
-	if err != nil {
-		c.logf("new request error: %v", err)
-		return err
+	req.Header.Set("Content-Type", "application/json")
+	for k, v := range headers {
+		req.Header.Set(k, v)
 	}
-	httpReq.Header.Set("Content-Type", "application/json")
-	httpReq.Header.Set("Authorization", "Bearer "+c.apiKey)
-	// Streaming uses SSE-style data lines
-	httpReq.Header.Set("Accept", "text/event-stream")
+	return c.httpClient.Do(req)
+}
 
-	resp, err := c.httpClient.Do(httpReq)
+func (c openAIClient) doJSONWithAccept(ctx context.Context, url string, body []byte, headers map[string]string, accept string) (*http.Response, error) {
+	req, err := http.NewRequestWithContext(ctx, http.MethodPost, url, bytes.NewReader(body))
 	if err != nil {
-		logging.Logf("llm/openai ", "%shttp error after %s: %v%s", logging.AnsiRed, time.Since(start), err, logging.AnsiBase)
-		return err
+		return nil, err
 	}
-	defer resp.Body.Close()
-	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
-		// try to decode body to surface message
-		var apiErr oaChatResponse
-		_ = json.NewDecoder(resp.Body).Decode(&apiErr)
-		if apiErr.Error != nil && apiErr.Error.Message != "" {
-			logging.Logf("llm/openai ", "%sapi error status=%d type=%s msg=%s duration=%s%s", logging.AnsiRed, resp.StatusCode, apiErr.Error.Type, apiErr.Error.Message, time.Since(start), logging.AnsiBase)
-			return fmt.Errorf("openai error: %s (status %d)", apiErr.Error.Message, resp.StatusCode)
-		}
-		logging.Logf("llm/openai ", "%shttp non-2xx status=%d duration=%s%s", logging.AnsiRed, resp.StatusCode, time.Since(start), logging.AnsiBase)
-		return fmt.Errorf("openai http error: status %d", resp.StatusCode)
+	req.Header.Set("Content-Type", "application/json")
+	req.Header.Set("Accept", accept)
+	for k, v := range headers {
+		req.Header.Set(k, v)
+	}
+	return c.httpClient.Do(req)
+}
+
+func handleOpenAINon2xx(resp *http.Response, start time.Time) error {
+	if resp.StatusCode >= 200 && resp.StatusCode < 300 {
+		return nil
+	}
+	var apiErr oaChatResponse
+	_ = json.NewDecoder(resp.Body).Decode(&apiErr)
+	if apiErr.Error != nil && apiErr.Error.Message != "" {
+		logging.Logf("llm/openai ", "%sapi error status=%d type=%s msg=%s duration=%s%s", logging.AnsiRed, resp.StatusCode, apiErr.Error.Type, apiErr.Error.Message, time.Since(start), logging.AnsiBase)
+		return fmt.Errorf("openai error: %s (status %d)", apiErr.Error.Message, resp.StatusCode)
+	}
+	logging.Logf("llm/openai ", "%shttp non-2xx status=%d duration=%s%s", logging.AnsiRed, resp.StatusCode, time.Since(start), logging.AnsiBase)
+	return fmt.Errorf("openai http error: status %d", resp.StatusCode)
+}
+
+func decodeOpenAIChat(resp *http.Response, start time.Time) (oaChatResponse, error) {
+	var out oaChatResponse
+	if err := json.NewDecoder(resp.Body).Decode(&out); err != nil {
+		logging.Logf("llm/openai ", "%sdecode error after %s: %v%s", logging.AnsiRed, time.Since(start), err, logging.AnsiBase)
+		return oaChatResponse{}, err
 	}
+	return out, nil
+}
 
+func parseOpenAIStream(resp *http.Response, start time.Time, onDelta func(string)) error {
 	// Parse SSE: lines starting with "data: " containing JSON or [DONE]
 	scanner := bufio.NewScanner(resp.Body)
-	// Increase buffer for long lines
 	const maxBuf = 1024 * 1024
 	buf := make([]byte, 0, 64*1024)
 	scanner.Buffer(buf, maxBuf)
@@ -283,7 +282,7 @@ func (c openAIClient) ChatStream(ctx context.Context, messages []Message, onDelt
 		}
 		var chunk oaStreamChunk
 		if err := json.Unmarshal([]byte(payload), &chunk); err != nil {
-			continue // skip malformed lines
+			continue
 		}
 		if chunk.Error != nil && chunk.Error.Message != "" {
 			logging.Logf("llm/openai ", "%sstream error: %s%s", logging.AnsiRed, chunk.Error.Message, logging.AnsiBase)
@@ -299,9 +298,5 @@ func (c openAIClient) ChatStream(ctx context.Context, messages []Message, onDelt
 		logging.Logf("llm/openai ", "%sstream read error after %s: %v%s", logging.AnsiRed, time.Since(start), err, logging.AnsiBase)
 		return err
 	}
-	logging.Logf("llm/openai ", "stream end duration=%s", time.Since(start))
 	return nil
 }
-
-// Private helpers
-func (c openAIClient) logf(format string, args ...any) { logging.Logf("llm/openai ", format, args...) }
diff --git a/internal/llm/openai_test.go b/internal/llm/openai_test.go
new file mode 100644
index 0000000..f50b171
--- /dev/null
+++ b/internal/llm/openai_test.go
@@ -0,0 +1,44 @@
+package llm
+
+import (
+    "bytes"
+    "encoding/json"
+    "io"
+    "net/http"
+    "strings"
+    "testing"
+    "time"
+)
+
+func f64p(v float64) *float64 { return &v }
+
+func TestBuildOAChatRequest_TempFallbackAndFields(t *testing.T) {
+    o := Options{Model: "m1", Temperature: 0, MaxTokens: 42, Stop: []string{"END"}}
+    msgs := []Message{{Role: "user", Content: "hi"}}
+    req := buildOAChatRequest(o, msgs, f64p(0.3), false)
+    if req.Model != "m1" || req.Stream { t.Fatalf("model/stream mismatch: %+v", req) }
+    if req.Temperature == nil || *req.Temperature != 0.3 { t.Fatalf("expected default temp 0.3, got %#v", req.Temperature) }
+    if req.MaxTokens == nil || *req.MaxTokens != 42 { t.Fatalf("expected max tokens 42") }
+    if len(req.Stop) != 1 || req.Stop[0] != "END" { t.Fatalf("stop not propagated: %#v", req.Stop) }
+    if len(req.Messages) != 1 || req.Messages[0].Content != "hi" { t.Fatalf("messages not copied") }
+
+    // stream on
+    req2 := buildOAChatRequest(o, msgs, f64p(0.3), true)
+    if !req2.Stream { t.Fatalf("expected stream=true") }
+}
+
+func TestHandleOpenAINon2xx_WithAPIError(t *testing.T) {
+    api := oaChatResponse{Error: &struct{ Message string `json:"message"`; Type string `json:"type"`; Param any `json:"param"`; Code any `json:"code"` }{Message: "bad", Type: "invalid"}}
+    b, _ := json.Marshal(api)
+    resp := &http.Response{StatusCode: 400, Body: io.NopCloser(bytes.NewReader(b))}
+    if err := handleOpenAINon2xx(resp, time.Now()); err == nil { t.Fatalf("expected error for non-2xx with body") }
+}
+
+func TestParseOpenAIStream_DeliversChunks(t *testing.T) {
+    stream := "data: {\"choices\":[{\"delta\":{\"content\":\"Hi\"}}]}\n\n" +
+        "data: [DONE]\n"
+    resp := &http.Response{Body: io.NopCloser(strings.NewReader(stream))}
+    var got strings.Builder
+    if err := parseOpenAIStream(resp, time.Now(), func(s string){ got.WriteString(s) }); err != nil { t.Fatalf("unexpected error: %v", err) }
+    if got.String() != "Hi" { t.Fatalf("got %q want %q", got.String(), "Hi") }
+}