Expand model fit runtime capability detection

Author: milliondreams

forge-go/api/modelfit.go

@@ -59,6 +59,22 @@ func (s *Server) handleListLocalModelFits() http.HandlerFunc {
 	}
 }
 
+func (s *Server) handleGetModelFitCapabilities() http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		svc := s.modelFit
+		if svc == nil {
+			svc = newModelFitService(forgepath.LocalModelCatalogPath(), forgepath.DependencyConfigPath(), modelfit.DefaultProfiler{})
+		}
+
+		system, err := svc.profiler.Profile(r.Context())
+		if err != nil {
+			ReplyError(w, http.StatusInternalServerError, err.Error())
+			return
+		}
+		ReplyJSON(w, http.StatusOK, system)
+	}
+}
+
 func parseBoolQuery(raw string) bool {
 	switch strings.TrimSpace(strings.ToLower(raw)) {
 	case "1", "true", "yes", "y", "on":

forge-go/api/modelfit_test.go

@@ -115,3 +115,54 @@ func TestRusticModelFitRouteRejectsInvalidLimit(t *testing.T) {
 	require.Equal(t, http.StatusBadRequest, rr.Code)
 	require.Contains(t, rr.Body.String(), "invalid limit")
 }
+
+func TestRusticModelFitCapabilitiesRouteReturnsSystemProfile(t *testing.T) {
+	t.Setenv("FORGE_ENABLE_PUBLIC_API", "false")
+	t.Setenv("FORGE_ENABLE_UI_API", "true")
+	t.Setenv("FORGE_IDENTITY_MODE", "local")
+	t.Setenv("FORGE_QUOTA_MODE", "local")
+
+	s := NewServer(nil, nil, nil, nil, nil, ":0").WithModelFit(
+		"",
+		"",
+		staticProfiler{profile: modelfit.SystemProfile{
+			TotalRAMBytes:             32 * 1024 * 1024 * 1024,
+			AvailableRAMBytes:         24 * 1024 * 1024 * 1024,
+			CPUCores:                  12,
+			Backend:                   modelfit.BackendCUDA,
+			RuntimeUsableAcceleration: true,
+			SelectedAcceleratorID:     "nvidia-0",
+			Confidence:                modelfit.DetectionConfidenceProbe,
+			ReasonCodes:               []modelfit.DiagnosticReason{modelfit.ReasonRuntimeDeviceDetected},
+			Runtime: modelfit.RuntimeCapabilityProfile{
+				RuntimeAvailable: true,
+				SelectedBackend:  modelfit.BackendCUDA,
+				Confidence:       modelfit.DetectionConfidenceProbe,
+				UsableAccelerators: []modelfit.UsableAccelerator{
+					{
+						ID:               "nvidia-0",
+						Vendor:           "nvidia",
+						Name:             "RTX 4090",
+						Backend:          modelfit.BackendCUDA,
+						Discrete:         true,
+						TotalMemoryBytes: 24 * 1024 * 1024 * 1024,
+					},
+				},
+			},
+		}},
+	)
+	router := s.buildRouter()
+
+	req := httptest.NewRequest(http.MethodGet, "/rustic/modelfit/capabilities", nil)
+	rr := httptest.NewRecorder()
+	router.ServeHTTP(rr, req)
+	require.Equal(t, http.StatusOK, rr.Code)
+
+	var system modelfit.SystemProfile
+	require.NoError(t, json.Unmarshal(rr.Body.Bytes(), &system))
+	require.True(t, system.RuntimeUsableAcceleration)
+	require.Equal(t, modelfit.BackendCUDA, system.Backend)
+	require.Equal(t, "nvidia-0", system.SelectedAcceleratorID)
+	require.Contains(t, system.ReasonCodes, modelfit.ReasonRuntimeDeviceDetected)
+	require.Len(t, system.Runtime.UsableAccelerators, 1)
+}

forge-go/api/server.go

@@ -152,6 +152,7 @@ func (s *Server) buildRouter() *gin.Engine {
 	if enableUI {
 		s.registerRusticUIRoutes(router, gemGen)
 		router.GET("/rustic/modelfit/local-models", wrapHTTP(s.handleListLocalModelFits()))
+		router.GET("/rustic/modelfit/capabilities", wrapHTTP(s.handleGetModelFitCapabilities()))
 		router.GET("/rustic/observe/guilds/:guild_id/messages/:msg_id/spans", wrapHTTPWithPathValues(s.handleObserveMessageSpans(), "guild_id", "msg_id"))
 		router.GET("/rustic/catalog/blueprints/:blueprint_id/dependencies", wrapHTTPWithPathValues(handleGetBlueprintDependencies(s.store), "blueprint_id"))
 		router.GET("/rustic/dependencies", wrapHTTP(handleListConfiguredDependencies()))