fix(providers): decode shared local probes per provider

Address the latest Copilot review comments on PR #30.

Local provider discovery still dedupes network requests by probe URL, but the shared work now stops at fetching the raw HTTP response. Each preset decodes that raw response separately with its own provider identity, so shared endpoints such as llama.cpp and LocalAI cannot inherit whichever provider happened to start the probe first. This preserves the one-request-per-endpoint behavior while keeping schema errors and model decoding provider-specific.

The local discovery UI type now models status as an actual closed union with an explicit unknown fallback instead of unioning the literals with string, which collapsed the type to plain string and removed useful compile-time checking.

Regression coverage asserts that shared invalid endpoint responses are requested once but produce provider-specific decode errors for every preset using that endpoint.

Verified with:

- cd ui && bun run typecheck

- cd ui && bun run test -- api provider-utils ProvidersView

- cd ui && bun run test

- GOCACHE=/Users/chicoxyzzy/dev/hecate/.gocache go test ./internal/api -run 'TestDiscoverLocalProviders|TestLocalProviderProbeURL'

- GOCACHE=/Users/chicoxyzzy/dev/hecate/.gocache go test ./internal/api

Author: chicoxyzzy

internal/api/handler_local_provider_discovery.go

@@ -1,10 +1,12 @@
 package api
 
 import (
+	"bytes"
 	"context"
 	"encoding/json"
 	"errors"
 	"fmt"
+	"io"
 	"net/http"
 	"net/url"
 	"os/exec"
@@ -29,6 +31,12 @@ type localHTTPProbeResult struct {
 	err       string
 }
 
+type localHTTPFetchResult struct {
+	statusCode int
+	body       []byte
+	err        string
+}
+
 type localProviderProbe struct {
 	provider config.BuiltInProvider
 	probeURL string
@@ -42,7 +50,7 @@ type localProviderDiscoveryResult struct {
 
 type localHTTPProbeTask struct {
 	done   chan struct{}
-	result localHTTPProbeResult
+	result localHTTPFetchResult
 }
 
 func (h *Handler) HandleLocalProviderDiscovery(w http.ResponseWriter, r *http.Request) {
@@ -111,7 +119,7 @@ func discoverLocalProviderPairsConcurrently(ctx context.Context, providers []loc
 	var probesMu sync.Mutex
 	var wg sync.WaitGroup
 
-	getProbe := func(probeURL, providerID string) *localHTTPProbeTask {
+	getProbe := func(probeURL string) *localHTTPProbeTask {
 		probesMu.Lock()
 		defer probesMu.Unlock()
 		if task, ok := probes[probeURL]; ok {
@@ -122,7 +130,7 @@ func discoverLocalProviderPairsConcurrently(ctx context.Context, providers []loc
 		go func() {
 			probeCtx, cancel := context.WithTimeout(ctx, localProviderDiscoveryTimeout)
 			defer cancel()
-			task.result = probeLocalProviderHTTP(probeCtx, client, probeURL, providerID)
+			task.result = fetchLocalProviderHTTP(probeCtx, client, probeURL)
 			close(task.done)
 		}()
 		return task
@@ -133,11 +141,11 @@ func discoverLocalProviderPairsConcurrently(ctx context.Context, providers []loc
 		go func() {
 			defer wg.Done()
 			command, path := findLocalProviderCommand(entry.provider.ID, lookPath)
-			task := getProbe(entry.probeURL, entry.provider.ID)
+			task := getProbe(entry.probeURL)
 			var httpResult localHTTPProbeResult
 			select {
 			case <-task.done:
-				httpResult = task.result
+				httpResult = decodeLocalProviderHTTPProbe(task.result, entry.provider.ID)
 			case <-ctx.Done():
 				httpResult = localHTTPProbeResult{err: compactLocalProbeError(ctx.Err())}
 			}
@@ -194,36 +202,47 @@ func localProviderProbeURL(provider config.BuiltInProvider) string {
 	return base + "/models"
 }
 
-func probeLocalProviderHTTP(ctx context.Context, client localProviderHTTPDoer, probeURL, providerID string) localHTTPProbeResult {
+func fetchLocalProviderHTTP(ctx context.Context, client localProviderHTTPDoer, probeURL string) localHTTPFetchResult {
 	req, err := http.NewRequestWithContext(ctx, http.MethodGet, probeURL, nil)
 	if err != nil {
-		return localHTTPProbeResult{err: err.Error()}
+		return localHTTPFetchResult{err: err.Error()}
 	}
 	resp, err := client.Do(req)
 	if err != nil {
-		return localHTTPProbeResult{err: compactLocalProbeError(err)}
+		return localHTTPFetchResult{err: compactLocalProbeError(err)}
 	}
 	defer resp.Body.Close()
 
-	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
-		return localHTTPProbeResult{err: fmt.Sprintf("HTTP %d", resp.StatusCode)}
+	body, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return localHTTPFetchResult{statusCode: resp.StatusCode, err: err.Error()}
+	}
+	return localHTTPFetchResult{statusCode: resp.StatusCode, body: body}
+}
+
+func decodeLocalProviderHTTPProbe(fetch localHTTPFetchResult, providerID string) localHTTPProbeResult {
+	if fetch.err != "" {
+		return localHTTPProbeResult{err: fetch.err}
+	}
+	if fetch.statusCode < 200 || fetch.statusCode >= 300 {
+		return localHTTPProbeResult{err: fmt.Sprintf("HTTP %d", fetch.statusCode)}
 	}
 
-	models, err := decodeLocalProviderModels(resp, providerID)
+	models, err := decodeLocalProviderModels(fetch.body, providerID)
 	if err != nil {
 		return localHTTPProbeResult{err: err.Error()}
 	}
 	return localHTTPProbeResult{available: true, models: models}
 }
 
-func decodeLocalProviderModels(resp *http.Response, providerID string) ([]string, error) {
+func decodeLocalProviderModels(body []byte, providerID string) ([]string, error) {
 	if providerID == "ollama" {
 		var payload struct {
 			Models []struct {
 				Name string `json:"name"`
 			} `json:"models"`
 		}
-		if err := json.NewDecoder(resp.Body).Decode(&payload); err != nil {
+		if err := json.NewDecoder(bytes.NewReader(body)).Decode(&payload); err != nil {
 			return nil, fmt.Errorf("invalid %s response: %w", providerID, err)
 		}
 		models := make([]string, 0, len(payload.Models))
@@ -240,7 +259,7 @@ func decodeLocalProviderModels(resp *http.Response, providerID string) ([]string
 			ID string `json:"id"`
 		} `json:"data"`
 	}
-	if err := json.NewDecoder(resp.Body).Decode(&payload); err != nil {
+	if err := json.NewDecoder(bytes.NewReader(body)).Decode(&payload); err != nil {
 		return nil, fmt.Errorf("invalid %s response: %w", providerID, err)
 	}
 	models := make([]string, 0, len(payload.Data))

internal/api/handler_local_provider_discovery_test.go

@@ -293,6 +293,37 @@ func TestDiscoverLocalProvidersRejectsInvalidHTTPProbeBody(t *testing.T) {
 	}
 }
 
+func TestDiscoverLocalProvidersDecodesSharedHTTPProbePerProvider(t *testing.T) {
+	t.Parallel()
+
+	providers := []config.BuiltInProvider{
+		{ID: "llamacpp", Name: "llama.cpp", Kind: "local", BaseURL: "http://127.0.0.1:8080/v1"},
+		{ID: "localai", Name: "LocalAI", Kind: "local", BaseURL: "http://127.0.0.1:8080/v1"},
+	}
+	rt := &localProviderRoundTrip{
+		body: map[string]string{
+			"http://127.0.0.1:8080/v1/models": `not-json`,
+		},
+	}
+
+	items := discoverLocalProviders(context.Background(), providers, missingLocalCommand, rt)
+
+	if len(items) != 2 {
+		t.Fatalf("items = %d, want 2", len(items))
+	}
+	if got := rt.calls["http://127.0.0.1:8080/v1/models"]; got != 1 {
+		t.Fatalf("shared endpoint request count = %d, want 1", got)
+	}
+	for _, item := range items {
+		if item.HTTPAvailable {
+			t.Fatalf("%s HTTPAvailable = true, want false", item.PresetID)
+		}
+		if !strings.Contains(item.Error, "invalid "+item.PresetID+" response") {
+			t.Fatalf("%s error = %q, want provider-specific decode error", item.PresetID, item.Error)
+		}
+	}
+}
+
 func TestLocalProviderProbeURLUsesOllamaNativeTagsEndpoint(t *testing.T) {
 	t.Parallel()
 

ui/src/types/runtime.ts

@@ -175,7 +175,7 @@ export type LocalProviderDiscoveryRecord = {
   name: string;
   base_url: string;
   probe_url: string;
-  status: "running" | "installed" | "not_detected" | "error" | string;
+  status: "running" | "installed" | "not_detected" | "error" | "unknown";
   command?: string;
   command_available: boolean;
   command_path?: string;